@ensdomains/ensjs 3.0.0-alpha.2 → 3.0.0-alpha.20

package/dist/esm/functions/getSpecificRecord.js

@@ -1,265 +0,0 @@
-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.js

@@ -1,152 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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>;