@ensdomains/ensjs 3.0.0-alpha.17 → 3.0.0-alpha.18

package/dist/esm/functions/getProfile.js

@@ -1,343 +0,0 @@
-import { formatsByName } from '@ensdomains/address-encoder';
-import { ethers } from 'ethers';
-import { decodeContenthash } from '../utils/contentHash';
-import { hexEncodeName } from '../utils/hexEncodedName';
-import { namehash } from '../utils/normalise';
-import { parseInputType } from '../utils/validation';
-const makeMulticallData = async ({ _getAddr, _getContentHash, _getText, resolverMulticallWrapper, }, name, options) => {
-    let calls = [];
-    options.texts &&
-        (calls = [
-            ...calls,
-            ...(await Promise.all(options.texts.map(async (x) => ({
-                key: x,
-                data: await _getText.raw(name, x),
-                type: 'text',
-            })))),
-        ]);
-    options.coinTypes &&
-        (calls = [
-            ...calls,
-            ...(await Promise.all(options.coinTypes.map(async (x) => ({
-                key: x,
-                data: await _getAddr.raw(name, x, true),
-                type: 'addr',
-            })))),
-        ]);
-    if (typeof options.contentHash === 'boolean' && options.contentHash) {
-        calls.push({
-            key: 'contentHash',
-            data: await _getContentHash.raw(name),
-            type: 'contenthash',
-        });
-    }
-    if (!calls.find((x) => x.key === '60')) {
-        calls.push({
-            key: '60',
-            data: await _getAddr.raw(name, '60', true),
-            type: 'addr',
-        });
-    }
-    const prRawData = await resolverMulticallWrapper.raw(calls.map((x) => x.data));
-    return { data: prRawData.data, calls };
-};
-const fetchWithoutResolverMulticall = async ({ multicallWrapper }, calls, resolverAddress) => {
-    const callsWithResolver = calls.map((call) => ({
-        to: resolverAddress,
-        data: call.data.data,
-    }));
-    return (await multicallWrapper(callsWithResolver)).map((x) => x[1]);
-};
-const getDataForName = async ({ contracts, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, name, options, fallbackResolver, specificResolver) => {
-    const universalResolver = await contracts?.getUniversalResolver();
-    const { data, calls } = await makeMulticallData({ _getAddr, _getContentHash, _getText, resolverMulticallWrapper }, name, options);
-    let resolvedData;
-    let useFallbackResolver = false;
-    try {
-        if (specificResolver) {
-            const publicResolver = await contracts?.getPublicResolver(undefined, specificResolver);
-            resolvedData = await publicResolver?.callStatic.multicall(calls.map((x) => x.data));
-        }
-        else {
-            resolvedData = await universalResolver?.resolve(hexEncodeName(name), data);
-        }
-    }
-    catch {
-        useFallbackResolver = true;
-    }
-    let resolverAddress;
-    let recordData;
-    if (useFallbackResolver) {
-        resolverAddress = specificResolver || fallbackResolver;
-        recordData = await fetchWithoutResolverMulticall({ multicallWrapper }, calls, resolverAddress);
-    }
-    else {
-        resolverAddress = specificResolver || resolvedData['1'];
-        if (specificResolver) {
-            recordData = resolvedData;
-        }
-        else {
-            ;
-            [recordData] = await resolverMulticallWrapper.decode(resolvedData['0']);
-        }
-    }
-    const matchAddress = recordData[calls.findIndex((x) => x.key === '60')];
-    return {
-        address: matchAddress && (await _getAddr.decode(matchAddress)),
-        records: await formatRecords({ _getAddr, _getContentHash, _getText }, recordData, calls, options),
-        resolverAddress,
-    };
-};
-const formatRecords = async ({ _getText, _getAddr, _getContentHash, }, data, calls, options) => {
-    let returnedRecords = (await Promise.all(data.map(async (item, i) => {
-        let decodedFromAbi;
-        let itemRet = {
-            key: calls[i].key,
-            type: calls[i].type,
-        };
-        if (itemRet.type === 'contenthash') {
-            decodedFromAbi = ethers.utils.defaultAbiCoder.decode(['bytes'], item)[0];
-            if (ethers.utils.hexStripZeros(decodedFromAbi) === '0x') {
-                return;
-            }
-        }
-        switch (calls[i].type) {
-            case 'text':
-                itemRet = {
-                    ...itemRet,
-                    value: await _getText.decode(item),
-                };
-                if (itemRet.value === '' || itemRet.value === undefined)
-                    return;
-                break;
-            case 'addr':
-                try {
-                    const addr = await _getAddr.decode(item, '', calls[i].key);
-                    if (addr) {
-                        itemRet = {
-                            ...itemRet,
-                            ...addr,
-                        };
-                        break;
-                    }
-                    else {
-                        return;
-                    }
-                }
-                catch {
-                    return;
-                }
-            case 'contenthash':
-                try {
-                    itemRet = {
-                        ...itemRet,
-                        value: await _getContentHash.decode(item),
-                    };
-                }
-                catch {
-                    return;
-                }
-        }
-        return itemRet;
-    })))
-        .filter((x) => {
-        return typeof x === 'object';
-    })
-        .filter((x) => x);
-    let returnedResponse = {};
-    if (typeof options.contentHash === 'string' ||
-        typeof options.contentHash === 'object') {
-        if (typeof options.contentHash === 'string' &&
-            ethers.utils.hexStripZeros(options.contentHash) === '0x') {
-            returnedResponse.contentHash = null;
-        }
-        else if (ethers.utils.isBytesLike(options.contentHash.decoded) &&
-            ethers.utils.hexStripZeros(options.contentHash.decoded) === '0x') {
-            returnedResponse.contentHash = null;
-        }
-        else {
-            returnedResponse.contentHash = options.contentHash;
-        }
-    }
-    else if (options.contentHash) {
-        const foundRecord = returnedRecords.find((item) => item.type === 'contenthash');
-        returnedResponse.contentHash = foundRecord ? foundRecord.value : null;
-    }
-    if (options.texts) {
-        returnedResponse.texts = returnedRecords.filter((x) => x.type === 'text');
-    }
-    if (options.coinTypes) {
-        returnedResponse.coinTypes = returnedRecords.filter((x) => x.type === 'addr');
-    }
-    return returnedResponse;
-};
-const graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress) => {
-    const query = gqlInstance.gql `
-    query getRecords($id: String!) {
-      domain(id: $id) {
-        isMigrated
-        createdAt
-        resolver {
-          texts
-          coinTypes
-          contentHash
-          addr {
-            id
-          }
-          address
-        }
-      }
-    }
-  `;
-    const customResolverQuery = gqlInstance.gql `
-    query getRecordsWithCustomResolver($id: String!, $resolverId: String!) {
-      domain(id: $id) {
-        isMigrated
-        createdAt
-      }
-      resolver(id: $resolverId) {
-        texts
-        coinTypes
-        contentHash
-        addr {
-          id
-        }
-      }
-    }
-  `;
-    const client = gqlInstance.client;
-    const id = namehash(name);
-    let domain;
-    let resolverResponse;
-    if (!resolverAddress) {
-        ;
-        ({ domain } = await client.request(query, { id }));
-        resolverResponse = domain?.resolver;
-    }
-    else {
-        const resolverId = `${resolverAddress.toLowerCase()}-${id}`;
-        ({ resolver: resolverResponse, domain } = await client.request(customResolverQuery, { id, resolverId }));
-    }
-    if (!domain)
-        return;
-    const { isMigrated, createdAt } = domain;
-    let returnedRecords = {};
-    if (!resolverResponse)
-        return { isMigrated, createdAt };
-    if (!wantedRecords)
-        return {
-            isMigrated,
-            createdAt,
-            graphResolverAddress: resolverResponse.address || resolverAddress,
-        };
-    Object.keys(wantedRecords).forEach((key) => {
-        const data = wantedRecords[key];
-        if (typeof data === 'boolean' && data) {
-            if (key === 'contentHash') {
-                returnedRecords[key] = decodeContenthash(resolverResponse.contentHash);
-            }
-            else {
-                returnedRecords[key] = resolverResponse[key];
-            }
-        }
-    });
-    return {
-        ...returnedRecords,
-        isMigrated,
-        createdAt,
-        graphResolverAddress: resolverResponse.address || resolverAddress,
-    };
-};
-const getProfileFromName = async ({ contracts, gqlInstance, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, name, options) => {
-    const { resolverAddress, ..._options } = options || {};
-    const optsLength = Object.keys(_options).length;
-    const usingOptions = !optsLength || _options?.texts === true || _options?.coinTypes === true
-        ? optsLength
-            ? _options
-            : { contentHash: true, texts: true, coinTypes: true }
-        : undefined;
-    const graphResult = await graphFetch({ gqlInstance }, name, usingOptions, resolverAddress);
-    if (!graphResult)
-        return;
-    const { isMigrated, createdAt, graphResolverAddress, ...wantedRecords } = graphResult;
-    if (!graphResolverAddress && !options?.resolverAddress)
-        return { isMigrated, createdAt, message: "Name doesn't have a resolver" };
-    const result = await getDataForName({
-        contracts,
-        _getAddr,
-        _getContentHash,
-        _getText,
-        resolverMulticallWrapper,
-        multicallWrapper,
-    }, name, usingOptions ? wantedRecords : options, graphResolverAddress, options?.resolverAddress);
-    if (!result)
-        return { isMigrated, createdAt, message: "Records fetch didn't complete" };
-    return { ...result, isMigrated, createdAt, message: undefined };
-};
-const getProfileFromAddress = async ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, address, options) => {
-    let name;
-    try {
-        name = await getName(address);
-    }
-    catch (e) {
-        return;
-    }
-    if (!name || !name.name || name.name === '')
-        return;
-    if (!name.match)
-        return { ...name, isMigrated: null, createdAt: null };
-    const result = await getProfileFromName({
-        contracts,
-        gqlInstance,
-        _getAddr,
-        _getContentHash,
-        _getText,
-        resolverMulticallWrapper,
-        multicallWrapper,
-    }, name.name, options);
-    if (!result || result.message)
-        return;
-    delete result.address;
-    return {
-        ...result,
-        ...name,
-        message: undefined,
-    };
-};
-export default async function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, nameOrAddress, options) {
-    if (options && options.coinTypes && typeof options.coinTypes !== 'boolean') {
-        options.coinTypes = options.coinTypes.map((coin) => {
-            if (!isNaN(parseInt(coin))) {
-                return coin;
-            }
-            else {
-                return `${formatsByName[coin.toUpperCase()].coinType}`;
-            }
-        });
-    }
-    const inputType = parseInputType(nameOrAddress);
-    if (inputType.type === 'unknown' || inputType.info === 'unsupported') {
-        throw new Error('Invalid input type');
-    }
-    if (inputType.type === 'address') {
-        return getProfileFromAddress({
-            contracts,
-            gqlInstance,
-            getName,
-            _getAddr,
-            _getContentHash,
-            _getText,
-            resolverMulticallWrapper,
-            multicallWrapper,
-        }, nameOrAddress, options);
-    }
-    return getProfileFromName({
-        contracts,
-        gqlInstance,
-        _getAddr,
-        _getContentHash,
-        _getText,
-        resolverMulticallWrapper,
-        multicallWrapper,
-    }, nameOrAddress, options);
-}

package/dist/esm/functions/getRecords.js

@@ -1,8 +0,0 @@
-import { parseInputType } from '../utils/validation';
-export default async function ({ getProfile }, name, options) {
-    const inputType = parseInputType(name);
-    if (inputType.type !== 'name' && inputType.type !== 'label') {
-        throw new Error('Input must be an ENS name');
-    }
-    return await getProfile(name, options);
-}

package/dist/esm/functions/getResolver.js

@@ -1,22 +0,0 @@
-import { ethers } from 'ethers';
-import { hexEncodeName } from '../utils/hexEncodedName';
-const raw = async ({ contracts }, name) => {
-    const universalResolver = await contracts?.getUniversalResolver();
-    return {
-        to: universalResolver.address,
-        data: universalResolver.interface.encodeFunctionData('findResolver', [
-            hexEncodeName(name),
-        ]),
-    };
-};
-const decode = async ({ contracts }, data) => {
-    const universalResolver = await contracts?.getUniversalResolver();
-    const response = universalResolver.interface.decodeFunctionResult('findResolver', data);
-    if (!response ||
-        !response[0] ||
-        ethers.utils.hexStripZeros(response[0]) === '0x') {
-        return;
-    }
-    return response[0];
-};
-export default { raw, decode };

package/dist/esm/functions/getSpecificRecord.js

@@ -1,272 +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) => {
-        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
-//   },
-// }