@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.10

package/dist/esm/functions/getOwner.js

@@ -0,0 +1,138 @@
+import { ethers } from 'ethers';
+import { labelhash } from '../utils/labels';
+import { namehash as makeNamehash } from '../utils/normalise';
+const singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels) => {
+    switch (contract) {
+        case 'nameWrapper': {
+            const nameWrapper = await contracts?.getNameWrapper();
+            return {
+                to: nameWrapper.address,
+                data: nameWrapper.interface.encodeFunctionData('ownerOf', [namehash]),
+            };
+        }
+        case 'registry': {
+            const registry = await contracts?.getRegistry();
+            return {
+                to: registry.address,
+                data: registry.interface.encodeFunctionData('owner', [namehash]),
+            };
+        }
+        case 'registrar': {
+            const registrar = await contracts?.getBaseRegistrar();
+            return {
+                to: registrar.address,
+                data: registrar.interface.encodeFunctionData('ownerOf', [
+                    labelhash(labels[0]),
+                ]),
+            };
+        }
+    }
+};
+const raw = async ({ contracts, multicallWrapper }, name, contract) => {
+    const namehash = makeNamehash(name);
+    const labels = name.split('.');
+    if (contract || labels.length === 1) {
+        return await singleContractOwnerRaw({ contracts }, contract || 'registry', namehash, labels);
+    }
+    const registryData = await singleContractOwnerRaw({ contracts }, 'registry', namehash, labels);
+    const nameWrapperData = await singleContractOwnerRaw({ contracts }, 'nameWrapper', namehash, labels);
+    const registrarData = await singleContractOwnerRaw({ contracts }, 'registrar', namehash, labels);
+    const data = [registryData, nameWrapperData];
+    if (labels.length == 2 && labels[1] === 'eth') {
+        data.push(registrarData);
+    }
+    return multicallWrapper.raw(data);
+};
+const singleContractOwnerDecode = (data) => ethers.utils.defaultAbiCoder.decode(['address'], data)[0];
+const decode = async ({ contracts, multicallWrapper }, data, name, contract) => {
+    if (data === null)
+        return;
+    const labels = name.split('.');
+    if (contract || labels.length === 1) {
+        const singleOwner = singleContractOwnerDecode(data);
+        let obj = {
+            ownershipLevel: contract || 'registry',
+        };
+        if (contract === 'registrar') {
+            return {
+                ...obj,
+                registrant: singleOwner,
+            };
+        }
+        else {
+            return {
+                ...obj,
+                owner: singleOwner,
+            };
+        }
+    }
+    const result = await multicallWrapper.decode(data);
+    if (result === null)
+        return;
+    const nameWrapper = await contracts?.getNameWrapper();
+    const decodedData = [result[0][1], result[1][1], result[2]?.[1]].map((ret) => ret &&
+        ret !== '0x' &&
+        ethers.utils.defaultAbiCoder.decode(['address'], ret));
+    const registryOwner = decodedData[0][0];
+    const nameWrapperOwner = decodedData[1][0];
+    const registrarOwner = decodedData[2]?.[0];
+    // check for only .eth names
+    if (labels[labels.length - 1] === 'eth') {
+        // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner
+        // there is no "registrant" for wrapped names
+        if (registrarOwner === nameWrapper.address) {
+            return {
+                owner: nameWrapperOwner,
+                ownershipLevel: 'nameWrapper',
+            };
+        }
+        // if there is a registrar owner, then it's not a subdomain but we have also passed the namewrapper clause
+        // this means that it's an unwrapped second-level name
+        // the registrant is the owner of the NFT
+        // the owner is the controller of the records
+        if (registrarOwner) {
+            return {
+                registrant: registrarOwner,
+                owner: registryOwner,
+                ownershipLevel: 'registrar',
+            };
+        }
+        if (labels.length > 2 &&
+            ethers.utils.hexStripZeros(registryOwner) !== '0x') {
+            // this means that the subname is wrapped
+            if (registryOwner === nameWrapper.address) {
+                return {
+                    owner: nameWrapperOwner,
+                    ownershipLevel: 'nameWrapper',
+                };
+            }
+            // unwrapped subnames do not have NFTs associated, so do not have a registrant
+            return {
+                owner: registryOwner,
+                ownershipLevel: 'registry',
+            };
+        }
+        // .eth names with no registrar owner are either unregistered or expired
+        return;
+    }
+    // non .eth names inherit the owner from the registry
+    // there will only ever be an owner for non .eth names, not a registrant
+    // this is because for unwrapped names, there is no associated NFT
+    // and for wrapped names, owner and registrant are the same thing
+    if (registryOwner == nameWrapper.address) {
+        return {
+            owner: nameWrapperOwner,
+            ownershipLevel: 'nameWrapper',
+        };
+    }
+    // for unwrapped non .eth names, the owner is the registry owner
+    if (ethers.utils.hexStripZeros(registryOwner) !== '0x') {
+        return {
+            owner: registryOwner,
+            ownershipLevel: 'registry',
+        };
+    }
+    // for anything else, return
+    return;
+};
+export default { raw, decode };

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

@@ -0,0 +1,13 @@
+import { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+declare const _default: {
+    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, duration: number, legacy?: boolean | undefined) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, _name: string, _number: number, legacy?: boolean | undefined) => Promise<{
+        base: BigNumber;
+        premium: BigNumber;
+    } | undefined>;
+};
+export default _default;

package/dist/esm/functions/getPrice.js

@@ -0,0 +1,48 @@
+import { utils } from 'ethers';
+const raw = async ({ contracts, multicallWrapper }, name, duration, legacy) => {
+    const controller = await contracts?.getEthRegistrarController();
+    const baseCall = {
+        to: controller.address,
+        data: controller.interface.encodeFunctionData('rentPrice', [
+            name,
+            duration,
+        ]),
+    };
+    if (legacy) {
+        return multicallWrapper.raw([
+            baseCall,
+            {
+                to: controller.address,
+                data: controller.interface.encodeFunctionData('rentPrice', [name, 0]),
+            },
+        ]);
+    }
+    return baseCall;
+};
+const decode = async ({ contracts, multicallWrapper }, data, _name, _number, legacy) => {
+    if (data === null)
+        return;
+    const controller = await contracts?.getEthRegistrarController();
+    try {
+        let base;
+        let premium;
+        if (legacy) {
+            const result = await multicallWrapper.decode(data);
+            const [price] = utils.defaultAbiCoder.decode(['uint256'], result[0].returnData);
+            [premium] = utils.defaultAbiCoder.decode(['uint256'], result[1].returnData);
+            base = price.sub(premium);
+        }
+        else {
+            ;
+            [base, premium] = controller.interface.decodeFunctionData('rentPrice', data);
+        }
+        return {
+            base,
+            premium,
+        };
+    }
+    catch {
+        return;
+    }
+};
+export default { raw, decode };

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

@@ -0,0 +1,33 @@
+import { ENSArgs } from '..';
+import { DecodedContentHash } from '../utils/contentHash';
+declare type DataItem = {
+    key: string | number;
+    type: 'addr' | 'text' | 'contentHash';
+    coin?: string;
+    value: string;
+};
+declare type ResolvedProfile = {
+    isMigrated: boolean | null;
+    createdAt: string | null;
+    address?: string;
+    name?: string | null;
+    match?: boolean;
+    message?: string;
+    records?: {
+        contentHash?: DecodedContentHash | string | null;
+        texts?: DataItem[];
+        coinTypes?: DataItem[];
+    };
+    resolverAddress?: string;
+    reverseResolverAddress?: string;
+};
+declare type ProfileOptions = {
+    contentHash?: boolean;
+    texts?: boolean | string[];
+    coinTypes?: boolean | string[];
+};
+declare type InputProfileOptions = ProfileOptions & {
+    resolverAddress?: string;
+};
+export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: InputProfileOptions): Promise<ResolvedProfile | undefined>;
+export {};

package/dist/esm/functions/getProfile.js

@@ -0,0 +1,343 @@
+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}-${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.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/esm/functions/getRecords.js

@@ -0,0 +1,8 @@
+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.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/esm/functions/getResolver.js

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