@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.61

package/dist/esm/functions/getOwner.js

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

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

@@ -1,299 +0,0 @@
-import { formatsByName } from '@ensdomains/address-encoder';
-import { ethers } from 'ethers';
-import { decodeContenthash } from '../utils/contentHash';
-import { hexEncodeName } from '../utils/hexEncodedName';
-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) => {
-    const universalResolver = await contracts?.getUniversalResolver();
-    const { data, calls } = await makeMulticallData({ _getAddr, _getContentHash, _getText, resolverMulticallWrapper }, name, options);
-    let resolvedData;
-    let useFallbackResolver = false;
-    try {
-        resolvedData = await universalResolver?.resolve(hexEncodeName(name), data);
-    }
-    catch {
-        useFallbackResolver = true;
-    }
-    let resolverAddress;
-    let recordData;
-    if (useFallbackResolver) {
-        resolverAddress = fallbackResolver;
-        recordData = await fetchWithoutResolverMulticall({ multicallWrapper }, calls, resolverAddress);
-    }
-    else {
-        resolverAddress = resolvedData['1'];
-        [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) => {
-    const query = gqlInstance.gql `
-    query getRecords($name: String!) {
-      domains(where: { name: $name }) {
-        isMigrated
-        createdAt
-        resolver {
-          texts
-          coinTypes
-          contentHash
-          addr {
-            id
-          }
-          address
-        }
-      }
-    }
-  `;
-    const client = gqlInstance.client;
-    const { domains } = await client.request(query, { name });
-    if (!domains || domains.length === 0)
-        return;
-    const [{ resolver: resolverResponse, isMigrated, createdAt }] = domains;
-    let returnedRecords = {};
-    if (!resolverResponse)
-        return { isMigrated, createdAt };
-    if (!wantedRecords)
-        return {
-            isMigrated,
-            createdAt,
-            graphResolverAddress: resolverResponse.address,
-        };
-    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,
-    };
-};
-const getProfileFromName = async ({ contracts, gqlInstance, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }, name, options) => {
-    const usingOptions = !options || options?.texts === true || options?.coinTypes === true
-        ? options || { contentHash: true, texts: true, coinTypes: true }
-        : undefined;
-    const graphResult = await graphFetch({ gqlInstance }, name, usingOptions);
-    if (!graphResult)
-        return;
-    const { isMigrated, createdAt, graphResolverAddress, ...wantedRecords } = graphResult;
-    if (!graphResolverAddress)
-        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);
-    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

@@ -1,32 +0,0 @@
-import { ENSArgs } from '..';
-declare type ProfileOptions = {
-    contentHash?: boolean;
-    texts?: boolean | string[];
-    coinTypes?: boolean | 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

@@ -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 };