@ensdomains/ensjs 2.0.0 → 3.0.0-alpha.1

package/dist/cjs/functions/getSubnames.d.ts

@@ -0,0 +1,26 @@
+import { ENSArgs } from '..';
+declare type Subname = {
+    id: string;
+    labelName: string | null;
+    truncatedName?: string;
+    labelhash: string;
+    isMigrated: boolean;
+    name: string;
+    owner: {
+        id: string;
+    };
+};
+declare type Params = {
+    name: string;
+    page?: number;
+    pageSize?: number;
+    orderDirection?: 'asc' | 'desc';
+    orderBy?: 'createdAt' | 'labelName';
+    lastSubnames: Array<any>;
+    isLargeQuery?: boolean;
+};
+declare const getSubnames: (injected: ENSArgs<'gqlInstance'>, functionArgs: Params) => Promise<{
+    subnames: Subname[];
+    subnameCount: number;
+}>;
+export default getSubnames;

package/dist/cjs/functions/getSubnames.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("ethers/lib/utils");
+const format_1 = require("../utils/format");
+const labels_1 = require("../utils/labels");
+const largeQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }) => {
+    const client = gqlInstance.client;
+    let finalQuery = gqlInstance.gql `
+    query getSubnames(
+      $id: ID! 
+      $first: Int
+      $lastCreatedAt: BigInt
+      $orderBy: Domain_orderBy 
+      $orderDirection: OrderDirection
+    ) {
+      domain(
+        id: $id
+      ) {
+        subdomainCount
+        subdomains(
+          first: $first
+          orderBy: $orderBy
+          orderDirection: $orderDirection
+          where: { createdAt_lt: $lastCreatedAt }
+        ) {
+          id
+          labelName
+          labelhash
+          isMigrated
+          name
+          subdomainCount
+          createdAt
+          owner {
+            id
+          }
+        }
+      }
+    }
+  `;
+    let queryVars = {
+        id: (0, utils_1.namehash)(name),
+        first: pageSize,
+        lastCreatedAt: lastSubnames[lastSubnames.length - 1]?.createdAt,
+        orderBy,
+        orderDirection,
+    };
+    const { domain } = await client.request(finalQuery, queryVars);
+    const subdomains = domain.subdomains.map((subname) => {
+        const decrypted = (0, labels_1.decryptName)(subname.name);
+        return {
+            ...subname,
+            name: decrypted,
+            truncatedName: (0, format_1.truncateFormat)(decrypted),
+        };
+    });
+    return {
+        subnames: subdomains,
+        subnameCount: domain.subdomainCount
+    };
+};
+const smallQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy }) => {
+    const client = gqlInstance.client;
+    const subdomainsGql = `
+  id
+  labelName
+  labelhash
+  isMigrated
+  name
+  subdomainCount
+  createdAt
+  owner {
+    id
+  }
+`;
+    let queryVars = {};
+    let finalQuery = '';
+    if (typeof page !== 'number') {
+        finalQuery = gqlInstance.gql `
+    query getSubnames(
+      $id: ID! 
+      $orderBy: Domain_orderBy 
+      $orderDirection: OrderDirection
+    ) {
+      domain(
+        id: $id
+      ) {
+        subdomains(
+          orderBy: $orderBy
+          orderDirection: $orderDirection
+        ) {
+          ${subdomainsGql}
+        }
+      }
+    }
+  `;
+        queryVars = {
+            id: (0, utils_1.namehash)(name),
+            orderBy,
+            orderDirection,
+        };
+    }
+    else {
+        finalQuery = gqlInstance.gql `
+    query getSubnames(
+      $id: ID! 
+      $first: Int
+      $skip: Int
+      $orderBy: Domain_orderBy 
+      $orderDirection: OrderDirection
+    ) {
+      domain(
+        id: $id
+      ) {
+        subdomainCount
+        subdomains(
+          first: $first
+          skip: $skip
+          orderBy: $orderBy
+          orderDirection: $orderDirection
+        ) {
+          ${subdomainsGql}
+        }
+      }
+    }
+  `;
+        queryVars = {
+            id: (0, utils_1.namehash)(name),
+            first: pageSize,
+            skip: (page || 0) * pageSize,
+            orderBy,
+            orderDirection,
+        };
+    }
+    const { domain } = await client.request(finalQuery, queryVars);
+    const subdomains = domain.subdomains.map((subname) => {
+        const decrypted = (0, labels_1.decryptName)(subname.name);
+        return {
+            ...subname,
+            name: decrypted,
+            truncatedName: (0, format_1.truncateFormat)(decrypted),
+        };
+    });
+    return {
+        subnames: subdomains,
+        subnameCount: domain.subdomainCount
+    };
+};
+const getSubnames = (injected, functionArgs) => {
+    if (functionArgs.isLargeQuery) {
+        return largeQuery(injected, functionArgs);
+    }
+    return smallQuery(injected, functionArgs);
+};
+exports.default = getSubnames;

package/dist/cjs/functions/initialGetters.d.ts

@@ -0,0 +1,11 @@
+export { default as batch } from './batch';
+export * from './batchWrappers';
+export { default as getExpiry } from './getExpiry';
+export { default as getName } from './getName';
+export { default as getNames } from './getNames';
+export { default as getOwner } from './getOwner';
+export { default as getPrice } from './getPrice';
+export { default as getProfile } from './getProfile';
+export { default as getRecords } from './getRecords';
+export * from './getSpecificRecord';
+export { default as getSubnames } from './getSubnames';

package/dist/cjs/functions/initialGetters.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSubnames = exports.getRecords = exports.getProfile = exports.getPrice = exports.getOwner = exports.getNames = exports.getName = exports.getExpiry = exports.batch = void 0;
+var batch_1 = require("./batch");
+Object.defineProperty(exports, "batch", { enumerable: true, get: function () { return __importDefault(batch_1).default; } });
+__exportStar(require("./batchWrappers"), exports);
+var getExpiry_1 = require("./getExpiry");
+Object.defineProperty(exports, "getExpiry", { enumerable: true, get: function () { return __importDefault(getExpiry_1).default; } });
+var getName_1 = require("./getName");
+Object.defineProperty(exports, "getName", { enumerable: true, get: function () { return __importDefault(getName_1).default; } });
+var getNames_1 = require("./getNames");
+Object.defineProperty(exports, "getNames", { enumerable: true, get: function () { return __importDefault(getNames_1).default; } });
+var getOwner_1 = require("./getOwner");
+Object.defineProperty(exports, "getOwner", { enumerable: true, get: function () { return __importDefault(getOwner_1).default; } });
+var getPrice_1 = require("./getPrice");
+Object.defineProperty(exports, "getPrice", { enumerable: true, get: function () { return __importDefault(getPrice_1).default; } });
+var getProfile_1 = require("./getProfile");
+Object.defineProperty(exports, "getProfile", { enumerable: true, get: function () { return __importDefault(getProfile_1).default; } });
+var getRecords_1 = require("./getRecords");
+Object.defineProperty(exports, "getRecords", { enumerable: true, get: function () { return __importDefault(getRecords_1).default; } });
+__exportStar(require("./getSpecificRecord"), exports);
+var getSubnames_1 = require("./getSubnames");
+Object.defineProperty(exports, "getSubnames", { enumerable: true, get: function () { return __importDefault(getSubnames_1).default; } });

package/dist/cjs/functions/setName.d.ts

@@ -0,0 +1,4 @@
+import { ENSArgs } from '..';
+export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, address?: string, resolver?: string, options?: {
+    addressOrIndex?: string | number;
+}): Promise<import("ethers").ContractTransaction | undefined>;

package/dist/cjs/functions/setName.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function default_1({ contracts, provider }, name, address, resolver, options) {
+    const signerAddress = await provider
+        ?.getSigner(options?.addressOrIndex)
+        .getAddress();
+    if (!signerAddress) {
+        throw new Error('No signer found');
+    }
+    const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(provider?.getSigner());
+    if (address) {
+        const publicResolver = await contracts?.getPublicResolver();
+        return reverseRegistrar?.setNameForAddr(address, signerAddress, resolver || publicResolver.address, name);
+    }
+    return reverseRegistrar?.setName(name);
+}
+exports.default = default_1;

package/dist/cjs/functions/setRecords.d.ts

@@ -0,0 +1,4 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+import { RecordOptions } from '../utils/recordHelpers';
+export default function ({ contracts, provider, getResolver, }: ENSArgs<'contracts' | 'provider' | 'getResolver'>, name: string, records: RecordOptions): Promise<ethers.ContractTransaction | undefined>;

package/dist/cjs/functions/setRecords.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const recordHelpers_1 = require("../utils/recordHelpers");
+async function default_1({ contracts, provider, getResolver, }, name, records) {
+    if (!name.includes('.')) {
+        throw new Error('Input is not an ENS name');
+    }
+    const resolverAddress = await getResolver(name);
+    if (!resolverAddress) {
+        throw new Error('No resolver found for input address');
+    }
+    const address = await provider?.getSigner().getAddress();
+    if (!address) {
+        throw new Error('No signer found');
+    }
+    const resolver = (await contracts?.getPublicResolver(provider, resolverAddress))?.connect(provider?.getSigner());
+    const namehash = ethers_1.ethers.utils.namehash(name);
+    const calls = (0, recordHelpers_1.generateRecordCallArray)(namehash, records, resolver);
+    return resolver?.multicall(calls);
+}
+exports.default = default_1;

package/dist/cjs/functions/setResolver.d.ts

@@ -0,0 +1,5 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, contract: 'registry' | 'nameWrapper', resolver?: string, options?: {
+    addressOrIndex?: string | number;
+}): Promise<ethers.ContractTransaction>;

package/dist/cjs/functions/setResolver.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+async function default_1({ contracts, provider }, name, contract, resolver, options) {
+    const address = await provider
+        ?.getSigner(options?.addressOrIndex)
+        .getAddress();
+    if (!address) {
+        throw new Error('No signer found');
+    }
+    if (!resolver) {
+        resolver = (await contracts?.getPublicResolver()).address;
+    }
+    switch (contract) {
+        case 'registry': {
+            const registry = (await contracts?.getRegistry()).connect(provider?.getSigner(options?.addressOrIndex));
+            return registry.setResolver(ethers_1.ethers.utils.namehash(name), resolver);
+        }
+        case 'nameWrapper': {
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
+            return nameWrapper.setResolver(ethers_1.ethers.utils.namehash(name), resolver);
+        }
+        default: {
+            throw new Error(`Unknown contract: ${contract}`);
+        }
+    }
+}
+exports.default = default_1;

package/dist/cjs/functions/transferName.d.ts

@@ -0,0 +1,5 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, newOwner: string, contract: 'registry' | 'nameWrapper' | 'baseRegistrar', options?: {
+    addressOrIndex?: string | number;
+}): Promise<ethers.ContractTransaction>;

package/dist/cjs/functions/transferName.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+async function default_1({ contracts, provider }, name, newOwner, contract, options) {
+    const address = await provider
+        ?.getSigner(options?.addressOrIndex)
+        .getAddress();
+    if (!address) {
+        throw new Error('No signer found');
+    }
+    switch (contract) {
+        case 'registry': {
+            const registry = (await contracts?.getRegistry()).connect(provider?.getSigner(options?.addressOrIndex));
+            return registry.setOwner(ethers_1.ethers.utils.namehash(name), newOwner);
+        }
+        case 'baseRegistrar': {
+            const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(provider?.getSigner(options?.addressOrIndex));
+            const labels = name.split('.');
+            if (labels.length > 2 || labels[labels.length - 1] !== 'eth') {
+                throw new Error('Invalid name for baseRegistrar');
+            }
+            return baseRegistrar['safeTransferFrom(address,address,uint256)'](address, newOwner, ethers_1.ethers.utils.solidityKeccak256(['string'], [labels[0]]));
+        }
+        case 'nameWrapper': {
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
+            return nameWrapper.safeTransferFrom(address, newOwner, ethers_1.ethers.utils.namehash(name), 1, '0x');
+        }
+        default: {
+            throw new Error(`Unknown contract: ${contract}`);
+        }
+    }
+}
+exports.default = default_1;

package/dist/cjs/functions/transferSubname.d.ts

@@ -0,0 +1,5 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, contract: 'registry' | 'nameWrapper', address: string, options?: {
+    addressOrIndex?: string | number;
+}): Promise<ethers.ContractTransaction>;

package/dist/cjs/functions/transferSubname.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+async function default_1({ contracts, provider }, name, contract, address, options) {
+    const signer = provider?.getSigner(options?.addressOrIndex);
+    if (!signer) {
+        throw new Error('No signer found');
+    }
+    const labels = name.split('.');
+    const label = labels.shift();
+    const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [label]);
+    const parentNodehash = ethers_1.ethers.utils.namehash(labels.join('.'));
+    switch (contract) {
+        case 'registry': {
+            const registry = (await contracts?.getRegistry()).connect(signer);
+            return registry.setSubnodeOwner(parentNodehash, labelhash, address);
+        }
+        case 'nameWrapper': {
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            return nameWrapper.setSubnodeOwner(parentNodehash, label, address, '0');
+        }
+        default: {
+            throw new Error(`Unknown contract: ${contract}`);
+        }
+    }
+}
+exports.default = default_1;

package/dist/cjs/functions/unwrapName.d.ts

@@ -0,0 +1,4 @@
+import { ENSArgs } from '..';
+export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, newController: string, newRegistrant?: string, options?: {
+    addressOrIndex?: string | number;
+}): Promise<import("ethers").ContractTransaction>;

package/dist/cjs/functions/unwrapName.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+async function default_1({ contracts, provider }, name, newController, newRegistrant, options) {
+    const signer = provider?.getSigner(options?.addressOrIndex);
+    const address = await signer?.getAddress();
+    if (!signer || !address) {
+        throw new Error('No signer found');
+    }
+    const labels = name.split('.');
+    const labelhash = ethers_1.utils.solidityKeccak256(['string'], [labels[0]]);
+    const parentNodehash = ethers_1.utils.namehash(labels.slice(1).join('.'));
+    const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+    if (labels.length === 2 && labels[1] === 'eth') {
+        if (!newRegistrant) {
+            throw new Error('newRegistrant must be specified for .eth names');
+        }
+        return nameWrapper.unwrapETH2LD(labelhash, newRegistrant, newController);
+    }
+    else {
+        if (newRegistrant) {
+            throw new Error('newRegistrant can only be specified for .eth names');
+        }
+        return nameWrapper.unwrap(parentNodehash, labelhash, newController);
+    }
+}
+exports.default = default_1;

package/dist/cjs/functions/wrapName.d.ts

@@ -0,0 +1,6 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+import type { FuseOptions } from '../@types/FuseOptions';
+export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, wrappedOwner: string, fuseOptions?: FuseOptions | string | number, resolverAddress?: string, options?: {
+    addressOrIndex?: string | number;
+}): Promise<ethers.ContractTransaction>;

package/dist/cjs/functions/wrapName.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
+const hexEncodedName_1 = require("../utils/hexEncodedName");
+async function wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address) {
+    const nameWrapper = await contracts?.getNameWrapper();
+    const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(signer);
+    const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [labels[0]]);
+    const data = ethers_1.ethers.utils.defaultAbiCoder.encode(['string', 'address', 'uint96', 'address'], [labels[0], wrappedOwner, decodedFuses, resolverAddress]);
+    return baseRegistrar['safeTransferFrom(address,address,uint256,bytes)'](address, nameWrapper.address, labelhash, data);
+}
+async function wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address) {
+    const nameWrapper = await contracts?.getNameWrapper();
+    const registry = await contracts?.getRegistry();
+    const hasApproval = await registry.isApprovedForAll(address, nameWrapper.address);
+    if (!hasApproval) {
+        throw new Error('NameWrapper must have approval to wrap a name from this address.');
+    }
+    return nameWrapper.wrap((0, hexEncodedName_1.hexEncodeName)(name), wrappedOwner, decodedFuses, resolverAddress);
+}
+async function default_1({ contracts, provider }, name, wrappedOwner, fuseOptions, resolverAddress, options) {
+    const signer = provider?.getSigner(options?.addressOrIndex);
+    const address = await signer?.getAddress();
+    if (!signer || !address) {
+        throw new Error('No signer found');
+    }
+    let decodedFuses;
+    switch (typeof fuseOptions) {
+        case 'object': {
+            decodedFuses = (0, generateFuseInput_1.default)(fuseOptions);
+            break;
+        }
+        case 'number': {
+            decodedFuses = fuseOptions.toString(16);
+            break;
+        }
+        case 'string': {
+            decodedFuses = fuseOptions;
+            break;
+        }
+        case 'undefined': {
+            decodedFuses = '0';
+            break;
+        }
+        default: {
+            throw new Error(`Invalid fuseOptions type: ${typeof fuseOptions}`);
+        }
+    }
+    const publicResolver = await contracts?.getPublicResolver();
+    if (!resolverAddress)
+        resolverAddress = publicResolver.address;
+    const labels = name.split('.');
+    if (labels.length < 3 && labels[labels.length - 1] === 'eth') {
+        return wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address);
+    }
+    else {
+        return wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address);
+    }
+}
+exports.default = default_1;