@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.2

package/dist/esm/functions/getSpecificRecord.js

@@ -0,0 +1,265 @@
+import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder';
+import { ethers } from 'ethers';
+import { decodeContenthash } from '../utils/contentHash';
+import { namehash } from '../utils/normalise';
+export const _getContentHash = {
+    raw: async ({ contracts }, name) => {
+        const publicResolver = await contracts?.getPublicResolver();
+        return {
+            to: '0x0000000000000000000000000000000000000000',
+            data: publicResolver.interface.encodeFunctionData('contenthash', [
+                namehash(name),
+            ]),
+        };
+    },
+    decode: async ({ contracts }, data) => {
+        const publicResolver = await contracts?.getPublicResolver();
+        const [response] = publicResolver.interface.decodeFunctionResult('contenthash', data);
+        if (!response) {
+            return;
+        }
+        const decodedContent = decodeContenthash(response);
+        if (!decodedContent ||
+            (ethers.utils.isBytesLike(decodedContent.decoded) &&
+                ethers.utils.hexStripZeros(decodedContent.decoded) === '0x') ||
+            Object.keys(decodedContent).length === 0) {
+            return;
+        }
+        return decodedContent;
+    },
+};
+export const getContentHash = {
+    raw: async ({ contracts, universalWrapper }, name) => {
+        const prData = await _getContentHash.raw({ contracts }, name);
+        return await universalWrapper.raw(name, prData.data);
+    },
+    decode: async ({ contracts, universalWrapper }, data) => {
+        const urData = await universalWrapper.decode(data);
+        if (!urData)
+            return;
+        return await _getContentHash.decode({ contracts }, urData.data);
+    },
+};
+export const _getText = {
+    raw: async ({ contracts }, name, key) => {
+        const publicResolver = await contracts?.getPublicResolver();
+        return {
+            to: '0x0000000000000000000000000000000000000000',
+            data: publicResolver.interface.encodeFunctionData('text', [
+                namehash(name),
+                key,
+            ]),
+        };
+    },
+    decode: async ({ contracts }, data) => {
+        const publicResolver = await contracts?.getPublicResolver();
+        const [response] = publicResolver.interface.decodeFunctionResult('text', data);
+        if (!response) {
+            return;
+        }
+        return response;
+    },
+};
+export const getText = {
+    raw: async ({ contracts, universalWrapper }, name, key) => {
+        const prData = await _getText.raw({ contracts }, name, key);
+        return await universalWrapper.raw(name, prData.data);
+    },
+    decode: async ({ contracts, universalWrapper }, data) => {
+        const urData = await universalWrapper.decode(data);
+        if (!urData)
+            return;
+        return await _getText.decode({ contracts }, urData.data);
+    },
+};
+export const _getAddr = {
+    raw: async ({ contracts }, name, coinType, bypassFormat) => {
+        if (!coinType) {
+            coinType = 60;
+        }
+        const publicResolver = await contracts?.getPublicResolver();
+        if (coinType === 60 || coinType === '60') {
+            return {
+                to: '0x0000000000000000000000000000000000000000',
+                data: publicResolver.interface.encodeFunctionData('addr(bytes32)', [
+                    namehash(name),
+                ]),
+            };
+        }
+        if (bypassFormat) {
+            return {
+                to: '0x0000000000000000000000000000000000000000',
+                data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [namehash(name), coinType]),
+            };
+        }
+        const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
+            ? formatsByName[coinType]
+            : formatsByCoinType[typeof coinType === 'number' ? coinType : parseInt(coinType)];
+        if (!formatter) {
+            throw new Error(`No formatter found for coin: ${coinType}`);
+        }
+        return {
+            to: '0x0000000000000000000000000000000000000000',
+            data: publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [namehash(name), formatter.coinType]),
+        };
+    },
+    decode: async ({ contracts }, data, _name, coinType) => {
+        let returnCoinType = true;
+        if (!coinType) {
+            coinType = 60;
+            returnCoinType = false;
+        }
+        const publicResolver = await contracts?.getPublicResolver();
+        const formatter = typeof coinType === 'string' && isNaN(parseInt(coinType))
+            ? formatsByName[coinType]
+            : formatsByCoinType[typeof coinType === 'number' ? coinType : parseInt(coinType)];
+        let response;
+        if (coinType === 60 || coinType === '60') {
+            ;
+            [response] = publicResolver.interface.decodeFunctionResult('addr(bytes32)', data);
+        }
+        else {
+            ;
+            [response] = publicResolver.interface.decodeFunctionResult('addr(bytes32,uint256)', data);
+        }
+        if (!response)
+            return;
+        if (ethers.utils.hexStripZeros(response) === '0x') {
+            return;
+        }
+        const decodedAddr = formatter.encoder(Buffer.from(response.slice(2), 'hex'));
+        if (!decodedAddr) {
+            return;
+        }
+        if (!returnCoinType) {
+            return decodedAddr;
+        }
+        return { coin: formatter.name, addr: decodedAddr };
+    },
+};
+export const getAddr = {
+    raw: async ({ contracts, universalWrapper }, name, coinType) => {
+        const prData = await _getAddr.raw({ contracts }, name, coinType);
+        return await universalWrapper.raw(name, prData.data);
+    },
+    decode: async ({ contracts, universalWrapper }, data, _name, coinType) => {
+        const urData = await universalWrapper.decode(data);
+        if (!urData)
+            return;
+        return await _getAddr.decode({ contracts }, urData.data, _name, coinType);
+    },
+};
+// export async function getAddr(
+//   { contracts }: ENSArgs<'contracts'>,
+//   name: string,
+//   coinType?: string | number,
+// ) {
+//   if (!coinType) {
+//     coinType = 60
+//   }
+//   const universalResolver = await contracts?.getUniversalResolver()
+//   const publicResolver = await contracts?.getPublicResolver()
+//   const formatter =
+//     typeof coinType === 'string'
+//       ? formatsByName[coinType]
+//       : formatsByCoinType[coinType]
+//   if (!formatter) {
+//     throw new Error(`Coin type ${coinType} is not supported`)
+//   }
+//   const data = publicResolver?.interface.encodeFunctionData(
+//     'addr(bytes32,uint256)',
+//     [ethers.utils.namehash(name), formatter.coinType],
+//   )
+//   const result = await universalResolver?.resolve(hexEncodeName(name), data)
+//   const [encodedAddr] = ethers.utils.defaultAbiCoder.decode(
+//     ['bytes'],
+//     result['0'],
+//   )
+//   if (ethers.utils.hexStripZeros(encodedAddr) === '0x') {
+//     return
+//   }
+//   const decodedAddr = formatter.encoder(
+//     Buffer.from(encodedAddr.slice(2), 'hex'),
+//   )
+//   if (!decodedAddr) {
+//     return
+//   }
+//   return decodedAddr
+// }
+// export const getContentHash = {
+//   raw: async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
+//     const universalResolver = await contracts?.getUniversalResolver()!
+//     const publicResolver = await contracts?.getPublicResolver()!
+//     const prData = publicResolver.interface.encodeFunctionData(
+//       'contenthash(bytes32)',
+//       [ethers.utils.namehash(name)],
+//     )
+//     const urData = universalResolver.interface.encodeFunctionData(
+//       'resolve(bytes,bytes)',
+//       [hexEncodeName(name), prData],
+//     )
+//     return {
+//       to: universalResolver.address,
+//       data: urData,
+//     }
+//   },
+//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+//     const universalResolver = await contracts?.getUniversalResolver()!
+//     const publicResolver = await contracts?.getPublicResolver()!
+//     const response = universalResolver.interface.decodeFunctionResult(
+//       'resolve(bytes,bytes)',
+//       data,
+//     )
+//     if (!response || !response[1]) {
+//       return
+//     }
+//     const [encodedContentHash] = publicResolver.interface.decodeFunctionResult(
+//       'contenthash(bytes32)',
+//       response[0],
+//     )
+//     if (ethers.utils.hexStripZeros(encodedContentHash) === '0x') {
+//       return
+//     }
+//     return decodeContenthash(encodedContentHash)
+//   },
+// }
+// const getText = {
+//   raw: async (
+//     { contracts }: ENSArgs<'contracts'>,
+//     name: string,
+//     key: string,
+//   ) => {
+//     const universalResolver = await contracts?.getUniversalResolver()!
+//     const publicResolver = await contracts?.getPublicResolver()!
+//     const data = publicResolver.interface.encodeFunctionData(
+//       'text(bytes32,string)',
+//       [ethers.utils.namehash(name), key],
+//     )
+//     return {
+//       to: universalResolver.address,
+//       data: universalResolver.interface.encodeFunctionData(
+//         'resolve(bytes,bytes)',
+//         [hexEncodeName(name), data],
+//       ),
+//     }
+//   },
+//   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+//     const universalResolver = await contracts?.getUniversalResolver()!
+//     const publicResolver = await contracts?.getPublicResolver()!
+//     const response = universalResolver.interface.decodeFunctionResult(
+//       'resolve(bytes,bytes)',
+//       data,
+//     )
+//     if (!response || !response[1]) {
+//       return
+//     }
+//     const [decodedText] = publicResolver.interface.decodeFunctionResult(
+//       'text(bytes32,string)',
+//       response[0],
+//     )
+//     if (decodedText === '') {
+//       return
+//     }
+//     return decodedText
+//   },
+// }

package/dist/esm/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/esm/functions/getSubnames.js

@@ -0,0 +1,152 @@
+import { truncateFormat } from '../utils/format';
+import { decryptName } from '../utils/labels';
+import { namehash } from '../utils/normalise';
+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: 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 = decryptName(subname.name);
+        return {
+            ...subname,
+            name: decrypted,
+            truncatedName: 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: 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: 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 = decryptName(subname.name);
+        return {
+            ...subname,
+            name: decrypted,
+            truncatedName: truncateFormat(decrypted),
+        };
+    });
+    return {
+        subnames: subdomains,
+        subnameCount: domain.subdomainCount,
+    };
+};
+const getSubnames = (injected, functionArgs) => {
+    if (functionArgs.isLargeQuery) {
+        return largeQuery(injected, functionArgs);
+    }
+    return smallQuery(injected, functionArgs);
+};
+export default getSubnames;

package/dist/esm/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/esm/functions/initialGetters.js

@@ -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/esm/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/esm/functions/setName.js

@@ -0,0 +1,14 @@
+export default async function ({ 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);
+}

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

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

package/dist/esm/functions/setRecords.js

@@ -0,0 +1,19 @@
+import { namehash } from '../utils/normalise';
+import { generateRecordCallArray } from '../utils/recordHelpers';
+export default async function ({ 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 hash = namehash(name);
+    const calls = generateRecordCallArray(hash, records, resolver);
+    return resolver?.multicall(calls);
+}

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

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

package/dist/esm/functions/setResolver.js

@@ -0,0 +1,25 @@
+import { namehash } from '../utils/normalise';
+export default async function ({ 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(namehash(name), resolver);
+        }
+        case 'nameWrapper': {
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
+            return nameWrapper.setResolver(namehash(name), resolver);
+        }
+        default: {
+            throw new Error(`Unknown contract: ${contract}`);
+        }
+    }
+}

package/dist/esm/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/esm/functions/transferName.js

@@ -0,0 +1,31 @@
+import { ethers } from 'ethers';
+import { namehash } from '../utils/normalise';
+export default async function ({ 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(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.utils.solidityKeccak256(['string'], [labels[0]]));
+        }
+        case 'nameWrapper': {
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(provider?.getSigner(options?.addressOrIndex));
+            return nameWrapper.safeTransferFrom(address, newOwner, namehash(name), 1, '0x');
+        }
+        default: {
+            throw new Error(`Unknown contract: ${contract}`);
+        }
+    }
+}

package/dist/esm/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/esm/functions/transferSubname.js

@@ -0,0 +1,25 @@
+import { ethers } from 'ethers';
+import { namehash } from '../utils/normalise';
+export default async function ({ 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.utils.solidityKeccak256(['string'], [label]);
+    const parentNodehash = 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}`);
+        }
+    }
+}

package/dist/esm/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/esm/functions/unwrapName.js

@@ -0,0 +1,25 @@
+import { utils } from 'ethers';
+import { namehash } from '../utils/normalise';
+export default async function ({ 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 = utils.solidityKeccak256(['string'], [labels[0]]);
+    const parentNodehash = 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);
+    }
+}

package/dist/esm/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>;