@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.10

package/dist/cjs/functions/getProfile.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const address_encoder_1 = require("@ensdomains/address-encoder");
+const ethers_1 = require("ethers");
+const contentHash_1 = require("../utils/contentHash");
+const hexEncodedName_1 = require("../utils/hexEncodedName");
+const normalise_1 = require("../utils/normalise");
+const validation_1 = require("../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((0, hexEncodedName_1.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_1.ethers.utils.defaultAbiCoder.decode(['bytes'], item)[0];
+            if (ethers_1.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_1.ethers.utils.hexStripZeros(options.contentHash) === '0x') {
+            returnedResponse.contentHash = null;
+        }
+        else if (ethers_1.ethers.utils.isBytesLike(options.contentHash.decoded) &&
+            ethers_1.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 = (0, normalise_1.namehash)(name);
+    let domain;
+    let resolverResponse;
+    if (!resolverAddress) {
+        ;
+        ({ domain } = await client.request(query, { id }));
+        resolverResponse = domain?.resolver;
+    }
+    else {
+        const resolverId = `${resolverAddress}-${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] = (0, contentHash_1.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,
+    };
+};
+async function default_1({ 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 `${address_encoder_1.formatsByName[coin.toUpperCase()].coinType}`;
+            }
+        });
+    }
+    const inputType = (0, validation_1.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);
+}
+exports.default = default_1;

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

@@ -0,0 +1,33 @@
+import { ENSArgs } from '..';
+declare type ProfileOptions = {
+    contentHash?: boolean;
+    texts?: boolean | string[];
+    coinTypes?: boolean | string[];
+    resolverAddress?: string;
+};
+export default function ({ getProfile }: ENSArgs<'getProfile'>, name: string, options?: ProfileOptions): Promise<{
+    isMigrated: boolean | null;
+    createdAt: string | null;
+    address?: string | undefined;
+    name?: string | null | undefined;
+    match?: boolean | undefined;
+    message?: string | undefined;
+    records?: {
+        contentHash?: string | import("../utils/contentHash").DecodedContentHash | null | undefined;
+        texts?: {
+            key: string | number;
+            type: "addr" | "text" | "contentHash";
+            coin?: string | undefined;
+            value: string;
+        }[] | undefined;
+        coinTypes?: {
+            key: string | number;
+            type: "addr" | "text" | "contentHash";
+            coin?: string | undefined;
+            value: string;
+        }[] | undefined;
+    } | undefined;
+    resolverAddress?: string | undefined;
+    reverseResolverAddress?: string | undefined;
+} | undefined>;
+export {};

package/dist/cjs/functions/getRecords.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validation_1 = require("../utils/validation");
+async function default_1({ getProfile }, name, options) {
+    const inputType = (0, validation_1.parseInputType)(name);
+    if (inputType.type !== 'name' && inputType.type !== 'label') {
+        throw new Error('Input must be an ENS name');
+    }
+    return await getProfile(name, options);
+}
+exports.default = default_1;

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

@@ -0,0 +1,9 @@
+import { ENSArgs } from '..';
+declare const _default: {
+    raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
+};
+export default _default;

package/dist/cjs/functions/getResolver.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const hexEncodedName_1 = require("../utils/hexEncodedName");
+const raw = async ({ contracts }, name) => {
+    const universalResolver = await contracts?.getUniversalResolver();
+    return {
+        to: universalResolver.address,
+        data: universalResolver.interface.encodeFunctionData('findResolver', [
+            (0, hexEncodedName_1.hexEncodeName)(name),
+        ]),
+    };
+};
+const decode = async ({ contracts }, data) => {
+    const universalResolver = await contracts?.getUniversalResolver();
+    const response = universalResolver.interface.decodeFunctionResult('findResolver', data);
+    if (!response ||
+        !response[0] ||
+        ethers_1.ethers.utils.hexStripZeros(response[0]) === '0x') {
+        return;
+    }
+    return response[0];
+};
+exports.default = { raw, decode };

package/dist/cjs/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>;
+};