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

package/dist/esm/index.d.ts

@@ -1,467 +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 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;
-    } | 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;
-    } | 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>;
-    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/index.js

@@ -1,207 +0,0 @@
-import ContractManager from './contracts';
-import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
-import GqlManager from './GqlManager';
-import singleCall from './utils/singleCall';
-import writeTx from './utils/writeTx';
-const graphURIEndpoints = {
-    1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
-    3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
-    4: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensrinkeby',
-    5: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensgoerli',
-};
-export class ENS {
-    constructor(options) {
-        this.getContractAddress = _getContractAddress;
-        this.gqlInstance = new GqlManager();
-        /**
-         * 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
-         */
-        this.checkInitialProvider = async () => {
-            if (!this.initialProvider) {
-                return;
-            }
-            await this.setProvider(this.initialProvider);
-            return;
-        };
-        /**
-         * Creates an object of ENS properties from an array
-         * @param {FunctionDeps} dependencies - An array of ENS properties
-         * @returns {Object} - An object of ENS properties
-         */
-        this.forwardDependenciesFromArray = (dependencies) => 
-        // Creates an object from entries of the array
-        Object.fromEntries(
-        // Maps over dependencies and create arrays for each, e.g. ['contracts', contractObj]
-        dependencies.map((dep) => [dep, this[dep]]));
-        /**
-         * 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
-         */
-        this.importGenerator = (path, dependencies, exportName = 'default', subFunc, passthrough) => {
-            // if batch is specified, create batch func
-            if (subFunc === 'batch') {
-                return (...args) => ({ args, ...passthrough });
-            }
-            const thisRef = this;
-            const mainFunc = async function (...args) {
-                // check the initial provider and set if it exists
-                await thisRef.checkInitialProvider();
-                // import the module dynamically
-                const mod = await import(
-                /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true */
-                `./functions/${path}`);
-                // if combine isn't specified, run normally
-                // otherwise, create a function from the raw and decode functions
-                if (subFunc !== 'combine') {
-                    const writeable = subFunc === 'write' || subFunc === 'populateTransaction';
-                    // get the function to call
-                    const func = subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName];
-                    // get the dependencies to forward to the function as the first arg
-                    let dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
-                    // if func is write func, inject signer into dependencies
-                    if (writeable) {
-                        const options = (args[1] || {});
-                        const signer = options.signer ||
-                            thisRef.provider?.getSigner(options.addressOrIndex);
-                        const populate = subFunc === 'populateTransaction';
-                        if (!signer) {
-                            throw new Error('No signer specified');
-                        }
-                        delete options.addressOrIndex;
-                        delete options.signer;
-                        dependenciesToForward = { ...dependenciesToForward, signer };
-                        return func(dependenciesToForward, args[0], options).then(writeTx(signer, populate));
-                    }
-                    // return the function with the dependencies forwarded
-                    return func(dependenciesToForward, ...args);
-                }
-                else {
-                    // get the dependencies to forward from raw and decode functions
-                    const dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
-                    // return singleCall function with dependencies forwarded
-                    return singleCall(thisRef.provider, dependenciesToForward, mod[exportName], ...args);
-                }
-            };
-            // if subfunc is combine, add raw and decode property methods to the function
-            if (subFunc === 'combine') {
-                mainFunc.raw = this.importGenerator(path, dependencies, exportName, 'raw');
-                mainFunc.decode = this.importGenerator(path, dependencies, exportName, 'decode');
-                mainFunc.batch = this.importGenerator(path, dependencies, exportName, 'batch', { raw: mainFunc.raw, decode: mainFunc.decode });
-            }
-            else if (subFunc === 'write') {
-                mainFunc.populateTransaction = this.importGenerator(path, dependencies, exportName, 'populateTransaction');
-            }
-            return mainFunc;
-        };
-        /**
-         * 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
-         */
-        this.generateFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName);
-        /**
-         * 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
-         */
-        this.generateWriteFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName, 'write');
-        /**
-         * 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
-         */
-        this.generateRawFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName, 'combine');
-        /**
-         * 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
-         */
-        this.setProvider = async (provider) => {
-            this.provider = provider;
-            const network = (await this.provider.getNetwork()).chainId;
-            if (this.options && this.options.graphURI) {
-                this.graphURI = this.options.graphURI;
-            }
-            else {
-                this.graphURI = graphURIEndpoints[network];
-            }
-            await this.gqlInstance.setUrl(this.graphURI);
-            this.contracts = new ContractManager(this.provider, this.getContractAddress(String(network)));
-            return;
-        };
-        /**
-         * 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
-         */
-        this.withProvider = (provider) => {
-            const newENS = new ENS(this.options);
-            newENS.initialProvider = provider;
-            return newENS;
-        };
-        this.batch = this.generateRawFunction('initialGetters', ['multicallWrapper'], 'batch');
-        this.getProfile = this.generateFunction('initialGetters', [
-            'contracts',
-            'gqlInstance',
-            'getName',
-            'resolverMulticallWrapper',
-            'multicallWrapper',
-            '_getAddr',
-            '_getContentHash',
-            '_getText',
-        ], 'getProfile');
-        this.getRecords = this.generateFunction('initialGetters', ['getProfile'], 'getRecords');
-        this.getName = this.generateRawFunction('initialGetters', ['contracts'], 'getName');
-        this.getResolver = this.generateRawFunction('getResolver', ['contracts']);
-        this.getFuses = this.generateRawFunction('getFuses', [
-            'contracts',
-        ]);
-        this.getHistory = this.generateFunction('getHistory', ['gqlInstance'], 'getHistory');
-        this.getHistoryWithDetail = this.generateFunction('getHistory', ['contracts', 'gqlInstance', 'provider'], 'getHistoryWithDetail');
-        this.getHistoryDetailForTransactionHash = this.generateFunction('getHistory', ['contracts', 'provider'], 'getHistoryDetailForTransactionHash');
-        this.getContentHash = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getContentHash');
-        this._getContentHash = this.generateRawFunction('initialGetters', ['contracts'], '_getContentHash');
-        this.getAddr = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getAddr');
-        this._getAddr = this.generateRawFunction('initialGetters', ['contracts'], '_getAddr');
-        this.getText = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getText');
-        this._getText = this.generateRawFunction('initialGetters', ['contracts'], '_getText');
-        this.getOwner = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getOwner');
-        this.getExpiry = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getExpiry');
-        this.getSubnames = this.generateFunction('initialGetters', ['gqlInstance'], 'getSubnames');
-        this.getNames = this.generateFunction('initialGetters', ['gqlInstance'], 'getNames');
-        this.getPrice = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getPrice');
-        this.universalWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'universalWrapper');
-        this.resolverMulticallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'resolverMulticallWrapper');
-        this.multicallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'multicallWrapper');
-        this.setName = this.generateWriteFunction('setName', [
-            'contracts',
-        ]);
-        this.setRecords = this.generateWriteFunction('setRecords', ['contracts', 'provider', 'getResolver']);
-        this.setResolver = this.generateWriteFunction('setResolver', ['contracts']);
-        this.transferName = this.generateWriteFunction('transferName', ['contracts']);
-        this.wrapName = this.generateWriteFunction('wrapName', [
-            'contracts',
-        ]);
-        this.unwrapName = this.generateWriteFunction('unwrapName', ['contracts']);
-        this.burnFuses = this.generateWriteFunction('burnFuses', [
-            'contracts',
-        ]);
-        this.createSubname = this.generateWriteFunction('createSubname', ['contracts']);
-        this.deleteSubname = this.generateWriteFunction('deleteSubname', ['transferSubname']);
-        this.transferSubname = this.generateWriteFunction('transferSubname', ['contracts']);
-        this.getDNSOwner = this.generateFunction('getDNSOwner', []);
-        this.options = options;
-        this.getContractAddress = options?.getContractAddress || _getContractAddress;
-    }
-}