@ensdomains/ensjs 3.0.0-alpha.9 → 3.0.0-beta.1

package/dist/esm/index.d.ts

@@ -1,472 +0,0 @@
-import { JsonRpcSigner } from '@ethersproject/providers';
-import { ContractTransaction, ethers, PopulatedTransaction } from 'ethers';
-import ContractManager from './contracts';
-import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
-import { SupportedNetworkId } from './contracts/types';
-import type burnFuses from './functions/burnFuses';
-import type createSubname from './functions/createSubname';
-import type deleteSubname from './functions/deleteSubname';
-import type setName from './functions/setName';
-import type setRecord from './functions/setRecord';
-import type setRecords from './functions/setRecords';
-import type setResolver from './functions/setResolver';
-import type transferName from './functions/transferName';
-import type transferSubname from './functions/transferSubname';
-import type unwrapName from './functions/unwrapName';
-import type wrapName from './functions/wrapName';
-import GqlManager from './GqlManager';
-declare type ENSOptions = {
-    graphURI?: string | null;
-    getContractAddress?: typeof _getContractAddress;
-};
-export declare type InternalENS = {
-    options?: ENSOptions;
-    provider?: ethers.providers.Provider;
-    signer: JsonRpcSigner;
-    graphURI?: string | null;
-} & ENS;
-export declare type ENSArgs<K extends keyof InternalENS> = {
-    [P in K]: InternalENS[P];
-};
-declare type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never;
-declare type OmitFirstTwoArgs<F> = F extends (x: any, y: any, ...args: infer P) => infer R ? (...args: P) => R : never;
-declare type WriteOptions = {
-    addressOrIndex?: string | number;
-    signer?: JsonRpcSigner;
-};
-declare type OptionalWriteOptions<F> = F extends (x: any, arg_0: infer Z, options?: infer P) => infer R ? (name: Z, options?: P & WriteOptions) => R : F extends (x: any, arg_0: infer Z, options: infer P) => infer R ? (name: Z, options: P & WriteOptions) => R : never;
-interface WriteFunction<F extends (...args: any) => any> extends Function {
-    (...args: Parameters<OptionalWriteOptions<F>>): Promise<ContractTransaction>;
-    populateTransaction: (...args: Parameters<OptionalWriteOptions<F>>) => Promise<PopulatedTransaction>;
-}
-export declare type RawFunction = {
-    raw: (...args: any[]) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: (...args: any[]) => Promise<any>;
-};
-export declare type BatchFunctionResult<F extends RawFunction> = {
-    args: Parameters<OmitFirstArg<F['raw']>>;
-    raw: F['raw'];
-    decode: F['decode'];
-};
-declare type BatchFunction<F extends RawFunction> = (...args: Parameters<OmitFirstArg<F['raw']>>) => BatchFunctionResult<F>;
-export declare type RawFunctionWithBatch = {
-    batch: BatchFunction<any>;
-} & RawFunction;
-interface GeneratedRawFunction<F extends RawFunction> extends Function, RawFunction {
-    (...args: Parameters<OmitFirstArg<F['raw']>>): ReturnType<OmitFirstTwoArgs<F['decode']>>;
-    batch: BatchFunction<F>;
-}
-export interface GenericGeneratedRawFunction extends Function, RawFunctionWithBatch {
-}
-export declare class ENS {
-    [x: string]: any;
-    protected options?: ENSOptions;
-    protected provider?: ethers.providers.JsonRpcProvider;
-    protected graphURI?: string | null;
-    protected initialProvider?: ethers.providers.JsonRpcProvider;
-    contracts?: ContractManager;
-    getContractAddress: (networkId: SupportedNetworkId) => import("./contracts/getContractAddress").ContractAddressFetch;
-    gqlInstance: GqlManager;
-    constructor(options?: ENSOptions);
-    /**
-     * Checks for an initial provider and if it exists, sets it as the provider
-     * @returns {Promise<void>} - A promise that resolves when the provider is checked, and set if needed
-     */
-    private checkInitialProvider;
-    /**
-     * Creates an object of ENS properties from an array
-     * @param {FunctionDeps} dependencies - An array of ENS properties
-     * @returns {Object} - An object of ENS properties
-     */
-    private forwardDependenciesFromArray;
-    /**
-     * Creates a wrapper for a function to be dynamically imported, with the correct dependencies passed in
-     * @param {string} path - The path of the exported function
-     * @param {FunctionDeps} dependencies - An array of ENS properties
-     * @param {string} exportName - The export name of the target function
-     * @param {string} subFunc - The type of function being imported
-     * @returns {Function} - The generated wrapped function
-     */
-    private importGenerator;
-    /**
-     * Generates a normal wrapped function
-     * @param {string} path - The path of the exported function
-     * @param {FunctionDeps} dependencies - An array of ENS properties
-     * @param {string} exportName - The export name of the target function
-     * @returns {OmitFirstArg} - The generated wrapped function
-     */
-    private generateFunction;
-    /**
-     * Generates a write wrapped function
-     * @param {string} path - The path of the exported function
-     * @param {FunctionDeps} dependencies - An array of ENS properties
-     * @param {string} exportName - The export name of the target function
-     * @returns {OmitFirstArg} - The generated wrapped function
-     */
-    private generateWriteFunction;
-    /**
-     * Generates a wrapped function from raw and decode exports
-     * @param {string} path - The path of the exported function
-     * @param {FunctionDeps} dependencies - An array of ENS properties
-     * @param {string} exportName - The export name of the target function
-     * @returns {GeneratedRawFunction} - The generated wrapped function
-     */
-    private generateRawFunction;
-    /**
-     * Sets the provider for the ENS class
-     * @param {ethers.providers.JsonRpcProvider} provider - The provider to set
-     * @returns {Promise<void>} - A promise that resolves when the provider is set
-     */
-    setProvider: (provider: ethers.providers.JsonRpcProvider) => Promise<void>;
-    /**
-     * Creates a new ENS instance with a different provider, ideally should be used individually with any given function
-     * @param {ethers.providers.JsonRpcProvider} provider - The provider to use
-     * @returns {ENS} - A new ENS instance with the given provider
-     */
-    withProvider: (provider: ethers.providers.JsonRpcProvider) => ENS;
-    batch: GeneratedRawFunction<{
-        raw: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, ...items: BatchFunctionResult<RawFunction>[]) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
-    }>;
-    getProfile: (nameOrAddress: string, options?: ({
-        contentHash?: boolean | undefined;
-        texts?: boolean | string[] | undefined;
-        coinTypes?: boolean | string[] | undefined;
-    } & {
-        resolverAddress?: string | undefined;
-    }) | undefined) => 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>;
-    getRecords: (name: string, options?: {
-        contentHash?: boolean | undefined;
-        texts?: boolean | string[] | undefined;
-        coinTypes?: boolean | string[] | undefined;
-        resolverAddress?: string | undefined;
-    } | undefined) => 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>;
-    getName: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, address: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string, address: string) => Promise<{
-            name: any;
-            match: boolean;
-            reverseResolverAddress: any;
-            resolverAddress: any;
-        } | {
-            name: null;
-            match: boolean;
-            reverseResolverAddress?: undefined;
-            resolverAddress?: undefined;
-        } | undefined>;
-    }>;
-    getResolver: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
-    }>;
-    getFuses: GeneratedRawFunction<{
-        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: ethers.BigNumber;
-        } | undefined>;
-    }>;
-    getHistory: (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>;
-    getHistoryWithDetail: (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>;
-    getHistoryDetailForTransactionHash: (hash: string, indexInTransaction?: number | undefined) => Promise<({
-        key: any;
-        value: any;
-    } | undefined)[] | {
-        key: any;
-        value: any;
-    } | undefined>;
-    getContentHash: GeneratedRawFunction<{
-        raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<{
-            protocolType?: undefined;
-            decoded?: undefined;
-            error?: undefined;
-        } | {
-            protocolType: null;
-            decoded: any;
-            error?: undefined;
-        } | {
-            protocolType: string | undefined;
-            decoded: any;
-            error: any;
-        } | undefined>;
-    }>;
-    _getContentHash: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
-            protocolType?: undefined;
-            decoded?: undefined;
-            error?: undefined;
-        } | {
-            protocolType: null;
-            decoded: any;
-            error?: undefined;
-        } | {
-            protocolType: string | undefined;
-            decoded: any;
-            error: any;
-        } | undefined>;
-    }>;
-    getAddr: GeneratedRawFunction<{
-        raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string, coinType?: string | number | undefined) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
-            coin: string;
-            addr: string;
-        } | undefined>;
-    }>;
-    _getAddr: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, name: string, coinType?: string | number | undefined, bypassFormat?: boolean | undefined) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
-            coin: string;
-            addr: string;
-        } | undefined>;
-    }>;
-    getText: GeneratedRawFunction<{
-        raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string, key: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<any>;
-    }>;
-    _getText: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, name: string, key: string) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
-    }>;
-    getOwner: GeneratedRawFunction<{
-        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
-            registrant?: string | undefined;
-            owner?: string | undefined;
-            ownershipLevel: "nameWrapper" | "registrar" | "registry";
-        } | undefined>;
-    }>;
-    getExpiry: GeneratedRawFunction<{
-        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>;
-    }>;
-    getSubnames: (functionArgs: {
-        name: string;
-        page?: number | undefined;
-        pageSize?: number | undefined;
-        orderDirection?: "asc" | "desc" | undefined;
-        orderBy?: "labelName" | "createdAt" | undefined;
-        lastSubnames: any[];
-        isLargeQuery?: boolean | undefined;
-    }) => Promise<{
-        subnames: {
-            id: string;
-            labelName: string | null;
-            truncatedName?: string | undefined;
-            labelhash: string;
-            isMigrated: boolean;
-            name: string;
-            owner: {
-                id: string;
-            };
-        }[];
-        subnameCount: number;
-    }>;
-    getNames: (args_0: {
-        address: string;
-        type: "owner" | "registrant" | "all";
-        page?: number | undefined;
-        pageSize?: number | undefined;
-        orderDirection?: "asc" | "desc" | undefined;
-    } & ({
-        type: "registrant";
-        orderBy?: "expiryDate" | "registrationDate" | "labelName" | undefined;
-    } | {
-        type: "owner";
-        orderBy?: "labelName" | "createdAt" | undefined;
-    } | {
-        type: "all";
-        orderBy?: "labelName" | "creationDate" | undefined;
-        page?: undefined;
-        pageSize?: undefined;
-    })) => Promise<import("./functions/getNames").Name[]>;
-    getPrice: GeneratedRawFunction<{
-        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: ethers.BigNumber;
-            premium: ethers.BigNumber;
-        } | undefined>;
-    }>;
-    universalWrapper: GeneratedRawFunction<{
-        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>;
-    }>;
-    resolverMulticallWrapper: GeneratedRawFunction<{
-        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>;
-    }>;
-    multicallWrapper: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean) => Promise<{
-            to: string;
-            data: string;
-        }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
-    }>;
-    setName: WriteFunction<typeof setName>;
-    setRecords: WriteFunction<typeof setRecords>;
-    setRecord: WriteFunction<typeof setRecord>;
-    setResolver: WriteFunction<typeof setResolver>;
-    transferName: WriteFunction<typeof transferName>;
-    wrapName: WriteFunction<typeof wrapName>;
-    unwrapName: WriteFunction<typeof unwrapName>;
-    burnFuses: WriteFunction<typeof burnFuses>;
-    createSubname: WriteFunction<typeof createSubname>;
-    deleteSubname: WriteFunction<typeof deleteSubname>;
-    transferSubname: WriteFunction<typeof transferSubname>;
-    getDNSOwner: (dnsName: string) => Promise<any>;
-}
-export {};

package/dist/esm/utils/contentHash.d.ts

@@ -1,28 +0,0 @@
-export declare type DecodedContentHash = {
-    protocolType?: any;
-    decoded?: any;
-    error?: any;
-};
-export declare function decodeContenthash(encoded: any): {
-    protocolType?: undefined;
-    decoded?: undefined;
-    error?: undefined;
-} | {
-    protocolType: null;
-    decoded: any;
-    error?: undefined;
-} | {
-    protocolType: string | undefined;
-    decoded: any;
-    error: any;
-};
-export declare function validateContent(encoded: any): any;
-export declare function isValidContenthash(encoded: any): boolean | undefined;
-export declare function getProtocolType(encoded: any): {
-    protocolType: string | undefined;
-    decoded: string | undefined;
-} | undefined;
-export declare function encodeContenthash(text: string): {
-    encoded: string | boolean;
-    error: string | undefined;
-};

package/dist/esm/utils/createReverseNode.d.ts

@@ -1,2 +0,0 @@
-declare const _default: (address: string) => string;
-export default _default;

package/dist/esm/utils/createReverseNode.js

@@ -1 +0,0 @@
-export default (address) => address.toLowerCase().substring(2) + '.addr.reverse';

package/dist/esm/utils/format.d.ts

@@ -1,3 +0,0 @@
-export declare const formatHashed: (name: string) => string;
-export declare const truncateFormat: (name: string) => string;
-export declare const bracketFormat: (name: string) => string;

package/dist/esm/utils/fuses.d.ts

@@ -1,20 +0,0 @@
-export declare const testable: {
-    CANNOT_UNWRAP: number;
-    CANNOT_BURN_FUSES: number;
-    CANNOT_TRANSFER: number;
-    CANNOT_SET_RESOLVER: number;
-    CANNOT_SET_TTL: number;
-    CANNOT_CREATE_SUBDOMAIN: number;
-    PARENT_CANNOT_CONTROL: number;
-};
-declare const _default: {
-    CAN_DO_EVERYTHING: number;
-    CANNOT_UNWRAP: number;
-    CANNOT_BURN_FUSES: number;
-    CANNOT_TRANSFER: number;
-    CANNOT_SET_RESOLVER: number;
-    CANNOT_SET_TTL: number;
-    CANNOT_CREATE_SUBDOMAIN: number;
-    PARENT_CANNOT_CONTROL: number;
-};
-export default _default;

package/dist/esm/utils/generateFuseInput.d.ts

@@ -1,3 +0,0 @@
-import { FuseOptions } from '../@types/FuseOptions';
-declare const _default: (fuseOptions: FuseOptions) => string;
-export default _default;

package/dist/esm/utils/generateFuseInput.js

@@ -1,14 +0,0 @@
-import { ethers } from 'ethers';
-import fuses from './fuses';
-export default (fuseOptions) => {
-    const fuseKeys = Object.keys(fuseOptions)
-        .filter((opt) => fuseOptions[opt] === true)
-        .map((opt) => opt
-        .split(/(?=[A-Z])/)
-        .join('_')
-        .toUpperCase());
-    const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
-        return prev.or(fuses[curr]);
-    }, ethers.BigNumber.from(0));
-    return bigNumberFuses.toHexString();
-};

package/dist/esm/utils/hexEncodedName.d.ts

@@ -1 +0,0 @@
-export declare const hexEncodeName: (name: string) => string;

package/dist/esm/utils/labels.d.ts

@@ -1,14 +0,0 @@
-export declare const labelhash: (input: string) => string;
-export declare const keccakFromString: (input: string) => string;
-export declare function decodeLabelhash(hash: string): string;
-export declare function encodeLabelhash(hash: string): string;
-export declare function isEncodedLabelhash(hash: string): boolean;
-export declare function saveLabel(label: string): string;
-export declare function saveName(name: string): void;
-export declare function checkLabel(hash: string): string | undefined;
-export declare function encodeLabel(label: any): any;
-export declare function parseName(name: string): string;
-export declare function checkIsDecrypted(string: string | string[]): boolean;
-export declare function decryptName(name: string): string;
-export declare const truncateUndecryptedName: (name: string) => string;
-export declare function checkLocalStorageSize(): string;

package/dist/esm/utils/makeHashIndexes.d.ts

@@ -1,2 +0,0 @@
-export declare const makeOtherIndexes: (data: string, findStr: string) => number[];
-export declare const makeNamehashIndexes: (data: string, name: string) => number[];

package/dist/esm/utils/makeHashIndexes.js

@@ -1,3 +0,0 @@
-import { namehash } from './normalise';
-export const makeOtherIndexes = (data, findStr) => Array.from(data.matchAll(findStr)).map((x) => x.index / 2 - 1);
-export const makeNamehashIndexes = (data, name) => Array.from(data.matchAll(namehash(name).substring(2))).map((x) => x.index / 2 - 1);

package/dist/esm/utils/normalise.d.ts

@@ -1,2 +0,0 @@
-export declare const normalise: (name: string) => any;
-export declare const namehash: (name: string) => string;

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

@@ -1,16 +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 type RecordTypes = 'contentHash' | 'text' | 'addr';
-export declare type RecordInput<T extends RecordTypes> = T extends 'contentHash' ? string : RecordItem;
-export declare function generateSingleRecordCall<T extends RecordTypes>(namehash: string, resolver: PublicResolver, type: T): (record: RecordInput<T>) => string;
-export declare const generateRecordCallArray: (namehash: string, records: RecordOptions, resolver: PublicResolver) => string[];
-export {};

package/dist/esm/utils/recordHelpers.js

@@ -1,65 +0,0 @@
-import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder';
-import { encodeContenthash } from './contentHash';
-export const generateSetAddr = (namehash, coinType, address, resolver) => {
-    let coinTypeInstance;
-    if (!isNaN(parseInt(coinType))) {
-        coinTypeInstance = formatsByCoinType[parseInt(coinType)];
-    }
-    else {
-        coinTypeInstance = formatsByName[coinType.toUpperCase()];
-    }
-    const inputCoinType = coinTypeInstance.coinType;
-    const encodedAddress = coinTypeInstance.decoder(address);
-    return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
-};
-export function generateSingleRecordCall(namehash, resolver, type) {
-    if (type === 'contentHash') {
-        return (_r) => {
-            const record = _r;
-            let _contentHash = '';
-            if (record !== _contentHash) {
-                const encoded = encodeContenthash(record);
-                if (encoded.error)
-                    throw new Error(encoded.error);
-                _contentHash = encoded.encoded;
-            }
-            return resolver.interface.encodeFunctionData('setContenthash', [
-                namehash,
-                _contentHash,
-            ]);
-        };
-    }
-    else {
-        return (_r) => {
-            const record = _r;
-            if (type === 'text') {
-                return resolver.interface.encodeFunctionData('setText', [
-                    namehash,
-                    record.key,
-                    record.value,
-                ]);
-            }
-            else {
-                return generateSetAddr(namehash, record.key, record.value, resolver);
-            }
-        };
-    }
-}
-export const generateRecordCallArray = (namehash, records, resolver) => {
-    const calls = [];
-    if (records.contentHash) {
-        const data = generateSingleRecordCall(namehash, resolver, 'contentHash')(records.contentHash);
-        data && calls.push(data);
-    }
-    if (records.texts && records.texts.length > 0) {
-        records.texts
-            .map(generateSingleRecordCall(namehash, resolver, 'text'))
-            .forEach((call) => calls.push(call));
-    }
-    if (records.coinTypes && records.coinTypes.length > 0) {
-        records.coinTypes
-            .map(generateSingleRecordCall(namehash, resolver, 'addr'))
-            .forEach((call) => calls.push(call));
-    }
-    return calls;
-};