@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

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

@@ -0,0 +1,73 @@
+import { ENSArgs } from '..';
+export declare const _getContentHash: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<{
+        protocolType?: undefined;
+        decoded?: undefined;
+        error?: undefined;
+    } | {
+        protocolType: null;
+        decoded: any;
+        error?: undefined;
+    } | {
+        protocolType: string | undefined;
+        decoded: any;
+        error: any;
+    } | undefined>;
+};
+export declare const getContentHash: {
+    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<{
+        protocolType?: undefined;
+        decoded?: undefined;
+        error?: undefined;
+    } | {
+        protocolType: null;
+        decoded: any;
+        error?: undefined;
+    } | {
+        protocolType: string | undefined;
+        decoded: any;
+        error: any;
+    } | undefined>;
+};
+export declare const _getText: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, key: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<any>;
+};
+export declare const getText: {
+    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, key: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<any>;
+};
+export declare const _getAddr: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, coinType?: string | number | undefined, bypassFormat?: boolean | undefined) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
+        coin: string;
+        addr: string;
+    } | undefined>;
+};
+export declare const getAddr: {
+    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, coinType?: string | number | undefined) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
+        coin: string;
+        addr: string;
+    } | undefined>;
+};

package/dist/esm/functions/getSpecificRecord.js

@@ -0,0 +1,272 @@
+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) => {
+        let response;
+        const publicResolver = await contracts?.getPublicResolver();
+        try {
+            ;
+            [response] = publicResolver.interface.decodeFunctionResult('contenthash', data);
+        }
+        catch {
+            return;
+        }
+        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,5 @@
+import { ENSArgs } from '..';
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { address, resolver, }?: {
+    address?: string;
+    resolver?: string;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/setName.js

@@ -0,0 +1,9 @@
+export default async function ({ contracts, signer }, name, { address, resolver, } = {}) {
+    const signerAddress = await signer.getAddress();
+    const reverseRegistrar = (await contracts?.getReverseRegistrar())?.connect(signer);
+    if (address) {
+        const publicResolver = await contracts?.getPublicResolver();
+        return reverseRegistrar.populateTransaction.setNameForAddr(address, signerAddress, resolver || publicResolver.address, name);
+    }
+    return reverseRegistrar.populateTransaction.setName(name);
+}

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

@@ -0,0 +1,18 @@
+import { ENSArgs } from '..';
+import { RecordInput, RecordTypes } from '../utils/recordHelpers';
+declare type BaseInput = {
+    resolverAddress?: string;
+};
+declare type ContentHashInput = {
+    record: RecordInput<'contentHash'>;
+    type: 'contentHash';
+};
+declare type AddrOrTextInput = {
+    record: RecordInput<'addr' | 'text'>;
+    type: 'addr' | 'text';
+};
+export default function <T extends RecordTypes>({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput)): Promise<{
+    to: string;
+    data: string;
+}>;
+export {};

package/dist/esm/functions/setRecord.js

@@ -0,0 +1,24 @@
+import { namehash } from '../utils/normalise';
+import { generateSingleRecordCall, } from '../utils/recordHelpers';
+export default async function ({ contracts, provider, getResolver, signer, }, name, { record, type, resolverAddress, }) {
+    if (!name.includes('.')) {
+        throw new Error('Input is not an ENS name');
+    }
+    let resolverToUse;
+    if (resolverAddress) {
+        resolverToUse = resolverAddress;
+    }
+    else {
+        resolverToUse = await getResolver(name);
+    }
+    if (!resolverToUse) {
+        throw new Error('No resolver found for input address');
+    }
+    const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
+    const hash = namehash(name);
+    const call = generateSingleRecordCall(hash, resolver, type)(record);
+    return {
+        to: resolver.address,
+        data: call,
+    };
+}

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

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

package/dist/esm/functions/setRecords.js

@@ -0,0 +1,21 @@
+import { namehash } from '../utils/normalise';
+import { generateRecordCallArray } from '../utils/recordHelpers';
+export default async function ({ contracts, provider, getResolver, signer, }, name, { records, resolverAddress, }) {
+    if (!name.includes('.')) {
+        throw new Error('Input is not an ENS name');
+    }
+    let resolverToUse;
+    if (resolverAddress) {
+        resolverToUse = resolverAddress;
+    }
+    else {
+        resolverToUse = await getResolver(name);
+    }
+    if (!resolverToUse) {
+        throw new Error('No resolver found for input address');
+    }
+    const resolver = (await contracts?.getPublicResolver(provider, resolverToUse))?.connect(signer);
+    const hash = namehash(name);
+    const calls = generateRecordCallArray(hash, records, resolver);
+    return resolver.populateTransaction.multicall(calls);
+}

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

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

package/dist/esm/functions/setResolver.js

@@ -0,0 +1,19 @@
+import { namehash } from '../utils/normalise';
+export default async function ({ contracts, signer }, name, { contract, resolver, }) {
+    if (!resolver) {
+        resolver = (await contracts?.getPublicResolver()).address;
+    }
+    switch (contract) {
+        case 'registry': {
+            const registry = (await contracts?.getRegistry()).connect(signer);
+            return registry.populateTransaction.setResolver(namehash(name), resolver);
+        }
+        case 'nameWrapper': {
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            return nameWrapper.populateTransaction.setResolver(namehash(name), resolver);
+        }
+        default: {
+            throw new Error(`Unknown contract: ${contract}`);
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newOwner, contract, }: {
+    newOwner: string;
+    contract: 'registry' | 'nameWrapper' | 'baseRegistrar';
+}): Promise<ethers.PopulatedTransaction>;