@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.10

package/dist/esm/index.d.ts

@@ -0,0 +1,472 @@
+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/index.js

@@ -0,0 +1,212 @@
+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, webpackExclude: /.*\.ts$/ */
+                `./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.setRecord = this.generateWriteFunction('setRecord', [
+            '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;
+    }
+}