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

package/dist/cjs/utils/recordHelpers.d.ts

@@ -1,13 +0,0 @@
-import type { PublicResolver } from '../generated';
-declare type RecordItem = {
-    key: string;
-    value: string;
-};
-export declare type RecordOptions = {
-    contentHash?: string;
-    texts?: RecordItem[];
-    coinTypes?: RecordItem[];
-};
-export declare const generateSetAddr: (namehash: string, coinType: string, address: string, resolver: PublicResolver) => string;
-export declare const generateRecordCallArray: (namehash: string, records: RecordOptions, resolver: PublicResolver) => string[];
-export {};

package/dist/cjs/utils/registerHelpers.d.ts

@@ -1,26 +0,0 @@
-import type { FuseOptions } from '../@types/FuseOptions';
-import type { PublicResolver } from '../generated';
-import { RecordOptions } from './recordHelpers';
-export declare const randomSecret: () => string;
-export declare const makeCommitment: ({ name, owner, duration, resolver, records, reverseRecord, fuses, }: {
-    name: string;
-    owner: string;
-    duration: number;
-    resolver: PublicResolver;
-    records?: RecordOptions | undefined;
-    reverseRecord?: boolean | undefined;
-    fuses?: FuseOptions | undefined;
-}) => {
-    secret: string;
-    commitment: string;
-};
-export declare const _makeCommitment: ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }: {
-    labelhash: string;
-    owner: string;
-    duration: number;
-    secret: string;
-    resolver: string;
-    data: string[];
-    reverseRecord: boolean;
-    fuses: string;
-}) => string;

package/dist/cjs/utils/singleCall.d.ts

@@ -1,9 +0,0 @@
-import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.Provider, ensData: any, func: {
-    raw: (...args: any[]) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: (...args: any[]) => Promise<any>;
-}, ...data: any[]) => Promise<any>;
-export default _default;

package/dist/cjs/utils/validation.d.ts

@@ -1,8 +0,0 @@
-export declare const validateName: (name: string) => string;
-export declare const validateTLD: (name: string) => string;
-declare type InputType = {
-    type: 'name' | 'label' | 'address' | 'unknown';
-    info?: 'short' | 'supported' | 'unsupported';
-};
-export declare const parseInputType: (input: string) => InputType;
-export {};

package/dist/cjs/utils/writeTx.d.ts

@@ -1,4 +0,0 @@
-import { JsonRpcSigner } from '@ethersproject/providers';
-import type { PopulatedTransaction } from 'ethers';
-declare const _default: (signer: JsonRpcSigner, populate: boolean) => (tx: PopulatedTransaction) => PopulatedTransaction | Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
-export default _default;

package/dist/esm/GqlManager.d.ts

@@ -1,6 +0,0 @@
-export default class GqlManager {
-    gql: any;
-    client?: any | null;
-    setUrl: (url: string | null) => Promise<void>;
-    request: (...arg: any[]) => any;
-}

package/dist/esm/GqlManager.js

@@ -1,18 +0,0 @@
-export default class GqlManager {
-    constructor() {
-        this.gql = () => null;
-        this.client = null;
-        this.setUrl = async (url) => {
-            if (url) {
-                const imported = await import('graphql-request');
-                this.client = new imported.GraphQLClient(url);
-                this.gql = imported.gql;
-            }
-            else {
-                this.client = null;
-                this.gql = () => null;
-            }
-        };
-        this.request = (...arg) => this.client ? this.client.request(...arg) : null;
-    }
-}

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

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

package/dist/esm/contracts/baseRegistrar.js

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

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

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

package/dist/esm/contracts/doNotCallOnChainUniversalResolverProxy.js

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

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

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

package/dist/esm/contracts/ethRegistrarController.js

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

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

@@ -1,3 +0,0 @@
-import { ContractName, SupportedNetworkId } from './types';
-export declare type ContractAddressFetch = (contractName: ContractName) => string;
-export declare const getContractAddress: (networkId: SupportedNetworkId) => ContractAddressFetch;

package/dist/esm/contracts/getContractAddress.js

@@ -1,42 +0,0 @@
-const addresses = {
-    BaseRegistrarImplementation: {
-        '1': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
-        '3': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
-        '4': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
-        '5': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
-    },
-    ETHRegistrarController: {
-        '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-        '3': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-        '4': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-        '5': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-    },
-    Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
-    NameWrapper: '0x0000000000000000000000000000000000000000',
-    PublicResolver: {
-        '1': '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
-    },
-    ENSRegistryWithFallback: {
-        '1': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
-        '3': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
-        '4': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
-        '5': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
-    },
-    ReverseRegistrar: {
-        '1': '0x084b1c3C81545d370f3634392De611CaaBFf8148',
-    },
-    UniversalResolver: {
-        '1': '0x580AF46E06DaaD47eb5940526FD64d95b815Cb70',
-        '4': '0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376',
-    },
-};
-export const getContractAddress = (networkId) => ((contractName) => {
-    try {
-        return typeof addresses[contractName] === 'string'
-            ? addresses[contractName]
-            : addresses[contractName][networkId];
-    }
-    catch {
-        throw new Error(`No address for contract ${contractName} on network ${networkId}`);
-    }
-});

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

@@ -1,16 +0,0 @@
-import { ethers } from 'ethers';
-import { ContractAddressFetch } from './getContractAddress';
-export default class ContractManager {
-    private provider;
-    private fetchAddress;
-    constructor(provider: ethers.providers.Provider, fetchAddress: ContractAddressFetch);
-    private generateContractGetter;
-    getPublicResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").PublicResolver>;
-    getUniversalResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").UniversalResolver>;
-    getRegistry: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/ENSRegistry").ENSRegistry>;
-    getReverseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ReverseRegistrar>;
-    getNameWrapper: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").NameWrapper>;
-    getBaseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation>;
-    getEthRegistrarController: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ETHRegistrarController>;
-    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/Multicall").Multicall>;
-}

package/dist/esm/contracts/index.js

@@ -1,29 +0,0 @@
-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

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

package/dist/esm/contracts/multicall.js

@@ -1,20 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

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

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

@@ -1,3 +0,0 @@
-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

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

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

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

package/dist/esm/contracts/registry.js

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

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

@@ -1,3 +0,0 @@
-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

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

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

@@ -1,2 +0,0 @@
-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

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

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

@@ -1,3 +0,0 @@
-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

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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.burnFuses(hash, encodedFuses);
-}

package/dist/esm/functions/createSubname.js

@@ -1,34 +0,0 @@
-import { ethers } from 'ethers';
-import generateFuseInput from '../utils/generateFuseInput';
-import { namehash } from '../utils/normalise';
-export default async function ({ contracts, signer }, 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 generatedFuses = 'fuses' in wrapperArgs && wrapperArgs.fuses
-                ? generateFuseInput(wrapperArgs.fuses)
-                : '0';
-            return nameWrapper.populateTransaction.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses);
-        }
-        default: {
-            throw new Error(`Unknown contract: ${contract}`);
-        }
-    }
-}

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

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

package/dist/esm/functions/deleteSubname.js

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

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

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

@@ -1,51 +0,0 @@
-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

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

package/dist/esm/functions/getExpiry.js

@@ -1,43 +0,0 @@
-import { solidityKeccak256 } from 'ethers/lib/utils';
-const raw = async ({ contracts, multicallWrapper }, name) => {
-    const baseRegistrar = await contracts?.getBaseRegistrar();
-    const labels = name.split('.');
-    if (labels.length > 2 || labels[1] !== 'eth') {
-        throw new Error('Only .eth names have expiry dates');
-    }
-    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 decode = async ({ contracts, multicallWrapper }, data) => {
-    if (data === null)
-        return;
-    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;
-    }
-};
-export default {
-    raw,
-    decode,
-};

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

@@ -1,17 +0,0 @@
-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]: any;
-        };
-        vulnerability: any;
-        vulnerableNode: null;
-        rawFuses: BigNumber;
-    } | undefined>;
-};
-export default _default;