@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

package/dist/esm/contracts/index.js

@@ -0,0 +1,29 @@
+import getBaseRegistrar from './baseRegistrar';
+import getEthRegistrarController from './ethRegistrarController';
+import getMulticall from './multicall';
+import getNameWrapper from './nameWrapper';
+import getPublicResolver from './publicResolver';
+import getRegistry from './registry';
+import getReverseRegistrar from './reverseRegistrar';
+import getUniversalResolver from './universalResolver';
+export default class ContractManager {
+    constructor(provider, fetchAddress) {
+        this.generateContractGetter = (name, func) => {
+            return async (passedProvider, address) => {
+                const inputAddress = address || this.fetchAddress(name);
+                const provider = passedProvider || this.provider;
+                return func(provider, inputAddress);
+            };
+        };
+        this.getPublicResolver = this.generateContractGetter('PublicResolver', getPublicResolver);
+        this.getUniversalResolver = this.generateContractGetter('UniversalResolver', getUniversalResolver);
+        this.getRegistry = this.generateContractGetter('ENSRegistryWithFallback', getRegistry);
+        this.getReverseRegistrar = this.generateContractGetter('ReverseRegistrar', getReverseRegistrar);
+        this.getNameWrapper = this.generateContractGetter('NameWrapper', getNameWrapper);
+        this.getBaseRegistrar = this.generateContractGetter('BaseRegistrarImplementation', getBaseRegistrar);
+        this.getEthRegistrarController = this.generateContractGetter('ETHRegistrarController', getEthRegistrarController);
+        this.getMulticall = this.generateContractGetter('Multicall', getMulticall);
+        this.provider = provider;
+        this.fetchAddress = fetchAddress;
+    }
+}

package/dist/esm/contracts/multicall.d.ts

@@ -0,0 +1,3 @@
+import { ethers } from 'ethers';
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").Multicall;
+export default _default;

package/dist/esm/contracts/multicall.js

@@ -0,0 +1,20 @@
+import { Multicall__factory } from '../generated/factories/Multicall__factory';
+const ABI = [
+    'function aggregate(tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes[] returnData)',
+    'function aggregate3(tuple(address target, bool allowFailure, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
+    'function aggregate3Value(tuple(address target, bool allowFailure, uint256 value, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
+    'function blockAndAggregate(tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes32 blockHash, tuple(bool success, bytes returnData)[] returnData)',
+    'function getBasefee() view returns (uint256 basefee)',
+    'function getBlockHash(uint256 blockNumber) view returns (bytes32 blockHash)',
+    'function getBlockNumber() view returns (uint256 blockNumber)',
+    'function getChainId() view returns (uint256 chainid)',
+    'function getCurrentBlockCoinbase() view returns (address coinbase)',
+    'function getCurrentBlockDifficulty() view returns (uint256 difficulty)',
+    'function getCurrentBlockGasLimit() view returns (uint256 gaslimit)',
+    'function getCurrentBlockTimestamp() view returns (uint256 timestamp)',
+    'function getEthBalance(address addr) view returns (uint256 balance)',
+    'function getLastBlockHash() view returns (bytes32 blockHash)',
+    'function tryAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)',
+    'function tryBlockAndAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (uint256 blockNumber, bytes32 blockHash, tuple(bool success, bytes returnData)[] returnData)',
+];
+export default (provider, address) => Multicall__factory.connect(address, provider);

package/dist/esm/contracts/nameWrapper.d.ts

@@ -0,0 +1,3 @@
+import { ethers } from 'ethers';
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").NameWrapper;
+export default _default;

package/dist/esm/contracts/nameWrapper.js

@@ -0,0 +1,2 @@
+import { NameWrapper__factory } from '../generated/factories/NameWrapper__factory';
+export default (provider, address) => NameWrapper__factory.connect(address, provider);

package/dist/esm/contracts/publicResolver.d.ts

@@ -0,0 +1,3 @@
+import { ethers } from 'ethers';
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").PublicResolver;
+export default _default;

package/dist/esm/contracts/publicResolver.js

@@ -0,0 +1,2 @@
+import { PublicResolver__factory } from '../generated/factories/PublicResolver__factory';
+export default (provider, address) => PublicResolver__factory.connect(address, provider);

package/dist/esm/contracts/registry.d.ts

@@ -0,0 +1,3 @@
+import { ethers } from 'ethers';
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ENSRegistry;
+export default _default;

package/dist/esm/contracts/registry.js

@@ -0,0 +1,2 @@
+import { ENSRegistry__factory } from '../generated/factories/ENSRegistry__factory';
+export default (provider, address) => ENSRegistry__factory.connect(address, provider);

package/dist/esm/contracts/reverseRegistrar.d.ts

@@ -0,0 +1,3 @@
+import { ethers } from 'ethers';
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ReverseRegistrar;
+export default _default;

package/dist/esm/contracts/reverseRegistrar.js

@@ -0,0 +1,2 @@
+import { ReverseRegistrar__factory } from '../generated/factories/ReverseRegistrar__factory';
+export default (provider, address) => ReverseRegistrar__factory.connect(address, provider);

package/dist/esm/contracts/types.d.ts

@@ -0,0 +1,2 @@
+export declare type SupportedNetworkId = '1' | '3' | '4' | '5' | '1337';
+export declare type ContractName = 'BaseRegistrarImplementation' | 'ETHRegistrarController' | 'Multicall' | 'NameWrapper' | 'PublicResolver' | 'ENSRegistryWithFallback' | 'ReverseRegistrar' | 'UniversalResolver';

package/dist/esm/contracts/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/contracts/universalResolver.d.ts

@@ -0,0 +1,3 @@
+import { ethers } from 'ethers';
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").UniversalResolver;
+export default _default;

package/dist/esm/contracts/universalResolver.js

@@ -0,0 +1,2 @@
+import { UniversalResolver__factory } from '../generated/factories/UniversalResolver__factory';
+export default (provider, address) => UniversalResolver__factory.connect(address, provider);

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

@@ -0,0 +1,9 @@
+import { BatchFunctionResult, ENSArgs, RawFunction } from '..';
+declare const _default: {
+    raw: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, ...items: BatchFunctionResult<RawFunction>[]) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
+};
+export default _default;

package/dist/esm/functions/batch.js

@@ -0,0 +1,19 @@
+const raw = async ({ multicallWrapper }, ...items) => {
+    const rawDataArr = await Promise.all(items.map(({ args, raw }, i) => {
+        if (!raw) {
+            throw new Error(`Function ${i} is not batchable`);
+        }
+        return raw(...args);
+    }));
+    return multicallWrapper.raw(rawDataArr);
+};
+const decode = async ({ multicallWrapper }, data, ...items) => {
+    const response = await multicallWrapper.decode(data);
+    if (!response)
+        return;
+    return Promise.all(response.map((ret, i) => items[i].decode(ret.returnData, ...items[i].args)));
+};
+export default {
+    raw,
+    decode,
+};

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

@@ -0,0 +1,29 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+export declare const universalWrapper: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, data: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<{
+        data: any;
+        resolver: any;
+    } | undefined>;
+};
+export declare const resolverMulticallWrapper: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, data: {
+        to: string;
+        data: string;
+    }[]) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<ethers.utils.Result | undefined>;
+};
+export declare const multicallWrapper: {
+    raw: ({ contracts }: ENSArgs<'contracts'>, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<any>;
+};

package/dist/esm/functions/batchWrappers.js

@@ -0,0 +1,68 @@
+import { hexEncodeName } from '../utils/hexEncodedName';
+export const universalWrapper = {
+    raw: async ({ contracts }, name, data) => {
+        const universalResolver = await contracts?.getUniversalResolver();
+        return {
+            to: universalResolver.address,
+            data: universalResolver.interface.encodeFunctionData('resolve', [
+                hexEncodeName(name),
+                data,
+            ]),
+        };
+    },
+    decode: async ({ contracts }, data) => {
+        const universalResolver = await contracts?.getUniversalResolver();
+        const response = universalResolver.interface.decodeFunctionResult('resolve', data);
+        if (!response || !response[0]) {
+            return;
+        }
+        return { data: response[0], resolver: response[1] };
+    },
+};
+export const resolverMulticallWrapper = {
+    raw: async ({ contracts }, data) => {
+        const publicResolver = await contracts?.getPublicResolver();
+        const formattedDataArr = data.map((item) => item.data);
+        return {
+            to: publicResolver.address,
+            data: publicResolver.interface.encodeFunctionData('multicall', [
+                formattedDataArr,
+            ]),
+        };
+    },
+    decode: async ({ contracts }, data) => {
+        const publicResolver = await contracts?.getPublicResolver();
+        const response = publicResolver.interface.decodeFunctionResult('multicall', data);
+        if (!response) {
+            return;
+        }
+        return response;
+    },
+};
+export const multicallWrapper = {
+    raw: async function ({ contracts }, transactions, requireSuccess = false) {
+        const multicall = await contracts?.getMulticall();
+        return {
+            to: multicall.address,
+            data: multicall.interface.encodeFunctionData('tryAggregate', [
+                requireSuccess,
+                transactions.map((tx) => ({
+                    target: tx.to,
+                    callData: tx.data,
+                })),
+            ]),
+        };
+    },
+    decode: async function ({ contracts }, data) {
+        if (!data)
+            return;
+        const multicall = await contracts?.getMulticall();
+        try {
+            const [result] = multicall.interface.decodeFunctionResult('tryAggregate', data);
+            return result;
+        }
+        catch {
+            return;
+        }
+    },
+};

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

@@ -0,0 +1,5 @@
+import { ENSArgs } from '..';
+import { FuseOptions } from '../@types/FuseOptions';
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { fusesToBurn, }: {
+    fusesToBurn: FuseOptions;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/burnFuses.js

@@ -0,0 +1,8 @@
+import generateFuseInput from '../utils/generateFuseInput';
+import { namehash } from '../utils/normalise';
+export default async function ({ contracts, signer }, name, { fusesToBurn, }) {
+    const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+    const hash = namehash(name);
+    const encodedFuses = generateFuseInput(fusesToBurn);
+    return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
+}

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

@@ -0,0 +1,17 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+import { FuseOptions } from '../@types/FuseOptions';
+import { Expiry } from '../utils/wrapperExpiry';
+declare type BaseArgs = {
+    owner: string;
+    resolverAddress?: string;
+    contract: 'registry' | 'nameWrapper';
+};
+declare type NameWrapperArgs = {
+    contract: 'nameWrapper';
+    fuses?: FuseOptions;
+    expiry?: Expiry;
+} & BaseArgs;
+declare type Args = BaseArgs | NameWrapperArgs;
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<ethers.PopulatedTransaction>;
+export {};

package/dist/esm/functions/createSubname.js

@@ -0,0 +1,36 @@
+import { ethers } from 'ethers';
+import generateFuseInput from '../utils/generateFuseInput';
+import { namehash } from '../utils/normalise';
+import { makeExpiry } from '../utils/wrapperExpiry';
+export default async function ({ contracts, signer, getExpiry, }, name, { owner, resolverAddress, contract, ...wrapperArgs }) {
+    const labels = name.split('.');
+    if (labels.length === 1) {
+        throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs');
+    }
+    if ('fuses' in wrapperArgs && contract === 'registry') {
+        throw new Error('Fuses can only be set on a wrapped name');
+    }
+    if (!resolverAddress) {
+        resolverAddress = (await contracts?.getPublicResolver()).address;
+    }
+    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.populateTransaction.setSubnodeRecord(parentNodehash, labelhash, owner, resolverAddress, 0);
+        }
+        case 'nameWrapper': {
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            const expiry = await makeExpiry({ getExpiry }, name, 'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined);
+            const generatedFuses = 'fuses' in wrapperArgs && wrapperArgs.fuses
+                ? generateFuseInput(wrapperArgs.fuses)
+                : '0';
+            return nameWrapper.populateTransaction.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses, expiry);
+        }
+        default: {
+            throw new Error(`Unknown contract: ${contract}`);
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+import { ENSArgs } from '..';
+export default function ({ transferSubname, signer }: ENSArgs<'transferSubname' | 'signer'>, name: string, { contract, }: {
+    contract: 'registry' | 'nameWrapper';
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/deleteSubname.js

@@ -0,0 +1,7 @@
+export default async function ({ transferSubname, signer }, name, { contract, }) {
+    return transferSubname.populateTransaction(name, {
+        contract,
+        owner: '0x0000000000000000000000000000000000000000',
+        signer,
+    });
+}

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

@@ -0,0 +1,7 @@
+import * as packet from 'dns-packet';
+export declare function encodeURLParams(p: {
+    [key: string]: string;
+}): string;
+export declare const getDNS: (q: packet.Packet) => Promise<packet.Packet>;
+export declare const dnsQuery: (qtype: string, qname: string) => Promise<packet.Packet>;
+export default function (_: any, dnsName: string): Promise<any>;

package/dist/esm/functions/getDNSOwner.js

@@ -0,0 +1,51 @@
+import * as packet from 'dns-packet';
+export function encodeURLParams(p) {
+    return Object.entries(p)
+        .map((kv) => kv.map(encodeURIComponent).join('='))
+        .join('&');
+}
+export const getDNS = async (q) => {
+    const response = await global.fetch(`https://cloudflare-dns.com/dns-query?${encodeURLParams({
+        ct: 'application/dns-udpwireformat',
+        dns: packet.encode(q)?.toString('base64'),
+        ts: Date.now().toString(),
+    })}`);
+    const arrayBuffer = await response.arrayBuffer();
+    // @ts-ignore:next-line
+    const fromArrayBuffer = Buffer.from(arrayBuffer);
+    return packet.decode(fromArrayBuffer);
+};
+export const dnsQuery = async (qtype, qname) => {
+    const query = {
+        type: 'query',
+        id: 1,
+        flags: packet.RECURSION_DESIRED,
+        questions: [
+            {
+                type: qtype,
+                class: 'IN',
+                name: qname,
+            },
+        ],
+        additionals: [
+            {
+                type: 'OPT',
+                class: 'IN',
+                name: '.',
+                udpPayloadSize: 4096,
+                flags: packet.DNSSEC_OK,
+            },
+        ],
+        answers: [],
+    };
+    const response = await getDNS(query);
+    if (response.rcode !== 'NOERROR') {
+        throw new Error(`DNS query failed: ${response.rcode}`);
+    }
+    return response;
+};
+export default async function (_, dnsName) {
+    const result = await dnsQuery('TXT', `_ens.${dnsName}`);
+    const address = result?.answers?.[0]?.data?.[0]?.toString()?.split('=')?.[1];
+    return address;
+}

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

@@ -0,0 +1,19 @@
+import { ENSArgs } from '..';
+declare type ContractOption = 'registrar' | 'nameWrapper';
+declare type Args = {
+    contract?: ContractOption;
+};
+declare const _default: {
+    raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: Args) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, { contract }?: Args) => Promise<{
+        expiry: Date;
+        gracePeriod: null;
+    } | {
+        expiry: Date | null;
+        gracePeriod: number;
+    } | undefined>;
+};
+export default _default;

package/dist/esm/functions/getExpiry.js

@@ -0,0 +1,88 @@
+import { solidityKeccak256 } from 'ethers/lib/utils';
+import { namehash } from '../utils/normalise';
+const getRegistrarExpiry = async ({ contracts, multicallWrapper }, labels) => {
+    if (labels.length > 2 || labels[1] !== 'eth') {
+        throw new Error('Only .eth names have expiry dates on the registrar');
+    }
+    const baseRegistrar = await contracts?.getBaseRegistrar();
+    const expiryCall = baseRegistrar.interface.encodeFunctionData('nameExpires', [
+        solidityKeccak256(['string'], [labels[0]]),
+    ]);
+    const gracePeriodCall = baseRegistrar.interface.encodeFunctionData('GRACE_PERIOD');
+    return multicallWrapper.raw([
+        {
+            to: baseRegistrar.address,
+            data: expiryCall,
+        },
+        {
+            to: baseRegistrar.address,
+            data: gracePeriodCall,
+        },
+    ]);
+};
+const getWrapperExpiry = async ({ contracts }, labels) => {
+    const nameWrapper = await contracts?.getNameWrapper();
+    const expiryCall = nameWrapper.interface.encodeFunctionData('getData', [
+        namehash(labels.join('.')),
+    ]);
+    return {
+        to: nameWrapper.address,
+        data: expiryCall,
+    };
+};
+const getContractToUse = (contract, labels) => {
+    if (contract)
+        return contract;
+    if (labels.length === 2 && labels[1] === 'eth') {
+        return 'registrar';
+    }
+    return 'nameWrapper';
+};
+const raw = async (ensArgs, name, { contract } = {}) => {
+    const labels = name.split('.');
+    const contractToUse = getContractToUse(contract, labels);
+    return contractToUse === 'nameWrapper'
+        ? getWrapperExpiry(ensArgs, labels)
+        : getRegistrarExpiry(ensArgs, labels);
+};
+const decodeRegistrarExpiry = async ({ contracts, multicallWrapper }, data) => {
+    const result = await multicallWrapper.decode(data);
+    const baseRegistrar = await contracts?.getBaseRegistrar();
+    try {
+        const [nameExpires] = baseRegistrar.interface.decodeFunctionResult('nameExpires', result[0].returnData);
+        const [gracePeriod] = baseRegistrar.interface.decodeFunctionResult('GRACE_PERIOD', result[1].returnData);
+        return {
+            expiry: nameExpires > 0 ? new Date(nameExpires * 1000) : null,
+            gracePeriod: gracePeriod.toNumber() * 1000,
+        };
+    }
+    catch {
+        return;
+    }
+};
+const decodeWrapperExpiry = async ({ contracts }, data) => {
+    const nameWrapper = await contracts?.getNameWrapper();
+    try {
+        const [_owner, _fuses, expiry] = nameWrapper.interface.decodeFunctionResult('getData', data);
+        return {
+            expiry: new Date(expiry * 1000),
+            gracePeriod: null,
+        };
+    }
+    catch {
+        return;
+    }
+};
+const decode = async (ensArgs, data, name, { contract } = {}) => {
+    if (data === null)
+        return;
+    const labels = name.split('.');
+    const contractToUse = getContractToUse(contract, labels);
+    return contractToUse === 'nameWrapper'
+        ? decodeWrapperExpiry(ensArgs, data)
+        : decodeRegistrarExpiry(ensArgs, data);
+};
+export default {
+    raw,
+    decode,
+};

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

@@ -0,0 +1,16 @@
+import { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+declare const _default: {
+    raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
+        fuseObj: {
+            [k: string]: boolean;
+        };
+        expiryDate: Date;
+        rawFuses: BigNumber;
+    } | undefined>;
+};
+export default _default;

package/dist/esm/functions/getFuses.js

@@ -0,0 +1,51 @@
+import { BigNumber } from 'ethers';
+import { testable as fuseEnums } from '../utils/fuses';
+import { namehash } from '../utils/normalise';
+const NameSafety = [
+    'Safe',
+    'RegistrantNotWrapped',
+    'ControllerNotWrapped',
+    'SubdomainReplacementAllowed',
+    'Expired',
+];
+const raw = async ({ contracts }, name) => {
+    const nameWrapper = await contracts?.getNameWrapper();
+    return {
+        to: nameWrapper.address,
+        data: nameWrapper.interface.encodeFunctionData('getFuses', [
+            namehash(name),
+        ]),
+    };
+};
+const decode = async ({ contracts }, data, name) => {
+    const nameWrapper = await contracts?.getNameWrapper();
+    try {
+        const [_fuses, expiry] = nameWrapper.interface.decodeFunctionResult('getFuses', data);
+        const fuses = BigNumber.from(_fuses);
+        const fuseObj = Object.fromEntries(Object.keys(fuseEnums).map((fuseEnum) => [
+            fuseEnum
+                .toLowerCase()
+                .replace(/([-_][a-z])/g, (group) => group.toUpperCase().replace('-', '').replace('_', '')),
+            fuses.and(fuseEnums[fuseEnum]).gt(0),
+        ]));
+        if (fuses.eq(0)) {
+            fuseObj.canDoEverything = true;
+        }
+        else {
+            fuseObj.canDoEverything = false;
+        }
+        const expiryDate = new Date(expiry * 1000);
+        return {
+            fuseObj,
+            expiryDate,
+            rawFuses: fuses,
+        };
+    }
+    catch {
+        return;
+    }
+};
+export default {
+    raw,
+    decode,
+};

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

@@ -0,0 +1,54 @@
+import { ENSArgs } from '..';
+export declare function getHistory({ gqlInstance }: ENSArgs<'gqlInstance'>, name: string): Promise<{
+    domain: {
+        type: any;
+        blockNumber: any;
+        transactionHash: any;
+        id: any;
+        data: Record<string, any>;
+    }[];
+    registration: {
+        type: any;
+        blockNumber: any;
+        transactionHash: any;
+        id: any;
+        data: Record<string, any>;
+    }[];
+    resolver: {
+        type: any;
+        blockNumber: any;
+        transactionHash: any;
+        id: any;
+        data: Record<string, any>;
+    }[];
+} | undefined>;
+export declare function getHistoryWithDetail({ contracts, gqlInstance, provider, }: ENSArgs<'contracts' | 'gqlInstance' | 'provider'>, name: string): Promise<{
+    domain: {
+        type: any;
+        blockNumber: any;
+        transactionHash: any;
+        id: any;
+        data: Record<string, any>;
+    }[];
+    registration: {
+        type: any;
+        blockNumber: any;
+        transactionHash: any;
+        id: any;
+        data: Record<string, any>;
+    }[];
+    resolver: {
+        type: any;
+        blockNumber: any;
+        transactionHash: any;
+        id: any;
+        data: Record<string, any>;
+    }[];
+} | undefined>;
+export declare function getHistoryDetailForTransactionHash({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, hash: string, indexInTransaction?: number): Promise<({
+    key: any;
+    value: any;
+} | undefined)[] | {
+    key: any;
+    value: any;
+} | undefined>;