@ensdomains/ensjs 3.0.0-alpha.4 → 3.0.0-alpha.40

package/dist/{esm → types}/index.d.ts

@@ -1,15 +1,18 @@
-import { ethers } from 'ethers';
-import ContractManager from './contracts';
+import { ContractTransaction, PopulatedTransaction } from '@ethersproject/contracts';
+import type { JsonRpcProvider, JsonRpcSigner, Provider } from '@ethersproject/providers';
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
+import ContractManager from './contracts/index';
 import { SupportedNetworkId } from './contracts/types';
 import GqlManager from './GqlManager';
+export type { Fuse, FuseArrayPossibilities, FuseObj, NamedFusesToBurn, UnnamedFuseType, UnnamedFuseValues, } from './utils/fuses';
 declare type ENSOptions = {
     graphURI?: string | null;
     getContractAddress?: typeof _getContractAddress;
 };
 export declare type InternalENS = {
     options?: ENSOptions;
-    provider?: ethers.providers.Provider;
+    provider?: Provider;
+    signer: JsonRpcSigner;
     graphURI?: string | null;
 } & ENS;
 export declare type ENSArgs<K extends keyof InternalENS> = {
@@ -17,6 +20,20 @@ export declare type ENSArgs<K extends keyof InternalENS> = {
 };
 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 FirstArg<F> = F extends (x: infer A, ...args: any[]) => any ? A : never;
+declare type FunctionDeps<F> = Extract<keyof FirstArg<F>, string>[];
+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 & {
+        customData?: Record<string, any>;
+    }>;
+    populateTransaction: (...args: Parameters<OptionalWriteOptions<F>>) => Promise<PopulatedTransaction>;
+}
+export declare const graphURIEndpoints: Record<string, string>;
 export declare type RawFunction = {
     raw: (...args: any[]) => Promise<{
         to: string;
@@ -39,12 +56,19 @@ interface GeneratedRawFunction<F extends RawFunction> extends Function, RawFunct
 }
 export interface GenericGeneratedRawFunction extends Function, RawFunctionWithBatch {
 }
+interface GeneratedBatchFunction<F extends RawFunction> extends Function, RawFunction {
+    <I extends BatchFunctionResult<RawFunction>[]>(...args: I): Promise<{
+        [N in keyof I]: I[N] extends BatchFunctionResult<infer U> ? Awaited<ReturnType<U['decode']>> : never;
+    } | undefined>;
+    batch: BatchFunction<F>;
+}
+export declare type FunctionSubtype = 'raw' | 'decode' | 'combine' | 'batch' | 'write' | 'populateTransaction';
 export declare class ENS {
     [x: string]: any;
     protected options?: ENSOptions;
-    protected provider?: ethers.providers.JsonRpcProvider;
+    protected provider?: JsonRpcProvider;
     protected graphURI?: string | null;
-    protected initialProvider?: ethers.providers.JsonRpcProvider;
+    protected initialProvider?: JsonRpcProvider;
     contracts?: ContractManager;
     getContractAddress: (networkId: SupportedNetworkId) => import("./contracts/getContractAddress").ContractAddressFetch;
     gqlInstance: GqlManager;
@@ -59,7 +83,9 @@ export declare class ENS {
      * @param {FunctionDeps} dependencies - An array of ENS properties
      * @returns {Object} - An object of ENS properties
      */
-    private forwardDependenciesFromArray;
+    protected forwardDependenciesFromArray: <F>(dependencies: FunctionDeps<F>) => object;
+    protected getModule: (path: string, exportName: string) => Promise<any>;
+    protected getFunction: (subFunc: FunctionSubtype | undefined, writeable: boolean | undefined, exportName: string, mod: any, _path: string) => any;
     /**
      * 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
@@ -77,6 +103,14 @@ export declare class ENS {
      * @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
@@ -87,28 +121,35 @@ export declare class ENS {
     private generateRawFunction;
     /**
      * Sets the provider for the ENS class
-     * @param {ethers.providers.JsonRpcProvider} provider - The provider to set
+     * @param {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>;
+    setProvider: (provider: 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
+     * @param {JsonRpcProvider} provider - The provider to use
      * @returns {ENS} - A new ENS instance with the given provider
      */
-    withProvider: (provider: ethers.providers.JsonRpcProvider) => ENS;
-    batch: GeneratedRawFunction<{
+    withProvider: (provider: JsonRpcProvider) => ENS;
+    batch: GeneratedBatchFunction<{
         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?: {
+    getProfile: (nameOrAddress: string, options?: ({
         contentHash?: boolean | undefined;
         texts?: boolean | string[] | undefined;
         coinTypes?: boolean | string[] | undefined;
-    } | undefined) => Promise<{
+    } & {
+        resolverAddress?: string | undefined;
+        fallback?: {
+            contentHash?: boolean | undefined;
+            texts?: string[] | undefined;
+            coinTypes?: string[] | undefined;
+        } | undefined;
+    }) | undefined) => Promise<{
         isMigrated: boolean | null;
         createdAt: string | null;
         address?: string | undefined;
@@ -119,24 +160,26 @@ export declare class ENS {
             contentHash?: string | import("./utils/contentHash").DecodedContentHash | null | undefined;
             texts?: {
                 key: string | number;
-                type: "addr" | "text" | "contentHash";
+                type: "text" | "addr" | "contentHash";
                 coin?: string | undefined;
                 value: string;
             }[] | undefined;
             coinTypes?: {
                 key: string | number;
-                type: "addr" | "text" | "contentHash";
+                type: "text" | "addr" | "contentHash";
                 coin?: string | undefined;
                 value: string;
             }[] | undefined;
         } | undefined;
         resolverAddress?: string | undefined;
+        isInvalidResolverAddress?: boolean | 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;
@@ -148,18 +191,19 @@ export declare class ENS {
             contentHash?: string | import("./utils/contentHash").DecodedContentHash | null | undefined;
             texts?: {
                 key: string | number;
-                type: "addr" | "text" | "contentHash";
+                type: "text" | "addr" | "contentHash";
                 coin?: string | undefined;
                 value: string;
             }[] | undefined;
             coinTypes?: {
                 key: string | number;
-                type: "addr" | "text" | "contentHash";
+                type: "text" | "addr" | "contentHash";
                 coin?: string | undefined;
                 value: string;
             }[] | undefined;
         } | undefined;
         resolverAddress?: string | undefined;
+        isInvalidResolverAddress?: boolean | undefined;
         reverseResolverAddress?: string | undefined;
     } | undefined>;
     getName: GeneratedRawFunction<{
@@ -173,8 +217,8 @@ export declare class ENS {
             reverseResolverAddress: any;
             resolverAddress: any;
         } | {
-            name: null;
-            match: boolean;
+            name: undefined;
+            match?: undefined;
             reverseResolverAddress?: undefined;
             resolverAddress?: undefined;
         } | undefined>;
@@ -186,73 +230,41 @@ export declare class ENS {
         }>;
         decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
     }>;
-    getFuses: GeneratedRawFunction<{
+    getWrapperData: 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;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
+            fuseObj: import("./utils/fuses").CurrentFuses;
+            expiryDate: Date;
+            rawFuses: import("@ethersproject/bignumber").BigNumber;
+            owner: any;
         } | 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>;
+            type: "Transfer" | "NewOwner" | "NewResolver" | "NewTTL" | "FusesSet" | "NameUnwrapped" | "NameWrapped" | "WrappedTransfer";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
         }[];
         registration: {
-            type: any;
-            blockNumber: any;
-            transactionHash: any;
-            id: any;
-            data: Record<string, any>;
+            type: "NameRegistered" | "NameRenewed" | "NameTransferred";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
         }[];
         resolver: {
-            type: any;
-            blockNumber: any;
-            transactionHash: any;
-            id: any;
-            data: Record<string, any>;
+            type: "AddrChanged" | "ContenthashChanged" | "InterfaceChanged" | "NameChanged" | "PubkeyChanged" | "TextChanged" | "VersionChanged" | "MulticoinAddrChanged" | "AbiChanged" | "AuthorisationChanged";
+            blockNumber: number;
+            transactionHash: string;
+            id: string;
+            data: object;
         }[];
     } | 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;
@@ -316,32 +328,39 @@ export declare class ENS {
             to: string;
             data: string;
         }>;
-        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<any>;
+        decode: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, data: string) => Promise<string | undefined>;
     }>;
     _getText: GeneratedRawFunction<{
         raw: ({ contracts }: ENSArgs<"contracts">, name: string, key: string) => Promise<{
             to: string;
             data: string;
         }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<string | undefined>;
     }>;
     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<{
+        decode: ({ contracts, multicallWrapper, gqlInstance, }: ENSArgs<"contracts" | "gqlInstance" | "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<{
+        raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: {
+            contract?: ("nameWrapper" | "registrar") | undefined;
+        }) => Promise<{
             to: string;
             data: string;
         }>;
-        decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string) => Promise<{
+        decode: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, { contract }?: {
+            contract?: ("nameWrapper" | "registrar") | undefined;
+        }) => Promise<{
+            expiry: Date;
+            gracePeriod: null;
+        } | {
             expiry: Date | null;
             gracePeriod: number;
         } | undefined>;
@@ -352,8 +371,8 @@ export declare class ENS {
         pageSize?: number | undefined;
         orderDirection?: "asc" | "desc" | undefined;
         orderBy?: "labelName" | "createdAt" | undefined;
-        lastSubnames: any[];
-        isLargeQuery?: boolean | undefined;
+        lastSubnames?: any[] | undefined;
+        search?: string | undefined;
     }) => Promise<{
         subnames: {
             id: string;
@@ -370,7 +389,7 @@ export declare class ENS {
     }>;
     getNames: (args_0: {
         address: string;
-        type: "owner" | "registrant" | "all";
+        type: "owner" | "wrappedOwner" | "registrant" | "all";
         page?: number | undefined;
         pageSize?: number | undefined;
         orderDirection?: "asc" | "desc" | undefined;
@@ -380,6 +399,9 @@ export declare class ENS {
     } | {
         type: "owner";
         orderBy?: "labelName" | "createdAt" | undefined;
+    } | {
+        type: "wrappedOwner";
+        orderBy?: "expiryDate" | "labelName" | undefined;
     } | {
         type: "all";
         orderBy?: "labelName" | "creationDate" | undefined;
@@ -387,15 +409,24 @@ export declare class ENS {
         pageSize?: undefined;
     })) => Promise<import("./functions/getNames").Name[]>;
     getPrice: GeneratedRawFunction<{
-        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, duration: number, legacy?: boolean | undefined) => Promise<{
+        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, nameOrNames: string | 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;
+        decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, _nameOrNames: string | string[], _duration: number, legacy?: boolean | undefined) => Promise<{
+            base: import("@ethersproject/bignumber").BigNumber;
+            premium: import("@ethersproject/bignumber").BigNumber;
         } | undefined>;
     }>;
+    getDNSOwner: (dnsName: string) => Promise<any>;
+    supportsTLD: (name: string) => Promise<boolean>;
+    getAvailable: GeneratedRawFunction<{
+        raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+            to: string;
+            data: string;
+        }>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<boolean | undefined>;
+    }>;
     universalWrapper: GeneratedRawFunction<{
         raw: ({ contracts }: ENSArgs<"contracts">, name: string, data: string) => Promise<{
             to: string;
@@ -414,58 +445,87 @@ export declare class ENS {
             to: string;
             data: string;
         }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<ethers.utils.Result | undefined>;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<import("@ethersproject/abi").Result | undefined>;
     }>;
     multicallWrapper: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean) => Promise<{
+        raw({ contracts }: ENSArgs<"contracts">, transactions: import("@ethersproject/abstract-provider").TransactionRequest[], requireSuccess?: boolean): Promise<{
             to: string;
             data: string;
         }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
+        decode({ contracts, provider }: ENSArgs<"provider" | "contracts">, data: string, transactions: import("@ethersproject/abstract-provider").TransactionRequest[]): Promise<{
+            success: boolean;
+            returnData: string;
+            0: boolean;
+            1: string;
+            length: 2;
+            toString(): string;
+            toLocaleString(): string;
+            pop(): string | boolean | undefined;
+            push(...items: (string | boolean)[]): number;
+            concat(...items: ConcatArray<string | boolean>[]): (string | boolean)[];
+            concat(...items: (string | boolean | ConcatArray<string | boolean>)[]): (string | boolean)[];
+            join(separator?: string | undefined): string;
+            reverse(): (string | boolean)[];
+            shift(): string | boolean | undefined;
+            slice(start?: number | undefined, end?: number | undefined): (string | boolean)[];
+            sort(compareFn?: ((a: string | boolean, b: string | boolean) => number) | undefined): [boolean, string];
+            splice(start: number, deleteCount?: number | undefined): (string | boolean)[];
+            splice(start: number, deleteCount: number, ...items: (string | boolean)[]): (string | boolean)[];
+            unshift(...items: (string | boolean)[]): number;
+            indexOf(searchElement: string | boolean, fromIndex?: number | undefined): number;
+            lastIndexOf(searchElement: string | boolean, fromIndex?: number | undefined): number;
+            every<S extends string | boolean>(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => value is S, thisArg?: any): this is S[];
+            every(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => unknown, thisArg?: any): boolean;
+            some(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => unknown, thisArg?: any): boolean;
+            forEach(callbackfn: (value: string | boolean, index: number, array: (string | boolean)[]) => void, thisArg?: any): void;
+            map<U>(callbackfn: (value: string | boolean, index: number, array: (string | boolean)[]) => U, thisArg?: any): U[];
+            filter<S_1 extends string | boolean>(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => value is S_1, thisArg?: any): S_1[];
+            filter(predicate: (value: string | boolean, index: number, array: (string | boolean)[]) => unknown, thisArg?: any): (string | boolean)[];
+            reduce(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean): string | boolean;
+            reduce(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean, initialValue: string | boolean): string | boolean;
+            reduce<U_1>(callbackfn: (previousValue: U_1, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => U_1, initialValue: U_1): U_1;
+            reduceRight(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean): string | boolean;
+            reduceRight(callbackfn: (previousValue: string | boolean, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => string | boolean, initialValue: string | boolean): string | boolean;
+            reduceRight<U_2>(callbackfn: (previousValue: U_2, currentValue: string | boolean, currentIndex: number, array: (string | boolean)[]) => U_2, initialValue: U_2): U_2;
+            find<S_2 extends string | boolean>(predicate: (this: void, value: string | boolean, index: number, obj: (string | boolean)[]) => value is S_2, thisArg?: any): S_2 | undefined;
+            find(predicate: (value: string | boolean, index: number, obj: (string | boolean)[]) => unknown, thisArg?: any): string | boolean | undefined;
+            findIndex(predicate: (value: string | boolean, index: number, obj: (string | boolean)[]) => unknown, thisArg?: any): number;
+            fill(value: string | boolean, start?: number | undefined, end?: number | undefined): [boolean, string];
+            copyWithin(target: number, start: number, end?: number | undefined): [boolean, string];
+            entries(): IterableIterator<[number, string | boolean]>;
+            keys(): IterableIterator<number>;
+            values(): IterableIterator<string | boolean>;
+            includes(searchElement: string | boolean, fromIndex?: number | undefined): boolean;
+            flatMap<U_3, This = undefined>(callback: (this: This, value: string | boolean, index: number, array: (string | boolean)[]) => U_3 | readonly U_3[], thisArg?: This | undefined): U_3[];
+            flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+            [Symbol.iterator](): IterableIterator<string | boolean>;
+            [Symbol.unscopables](): {
+                copyWithin: boolean;
+                entries: boolean;
+                fill: boolean;
+                find: boolean;
+                findIndex: boolean;
+                keys: boolean;
+                values: boolean;
+            };
+            at(index: number): string | boolean | undefined;
+        }[] | undefined>;
     }>;
-    setName: (name: string, address?: string | undefined, resolver?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction | undefined>;
-    setRecords: (name: string, records: import("./utils/recordHelpers").RecordOptions) => Promise<ethers.ContractTransaction | undefined>;
-    setResolver: (name: string, contract: "nameWrapper" | "registry", resolver?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    transferName: (name: string, newOwner: string, contract: "nameWrapper" | "registry" | "baseRegistrar", options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    wrapName: (name: string, wrappedOwner: string, fuseOptions?: string | number | import("./@types/FuseOptions").FuseOptions | undefined, resolverAddress?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    unwrapName: (name: string, newController: string, newRegistrant?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    burnFuses: (name: string, fusesToBurn: import("./@types/FuseOptions").FuseOptions) => Promise<ethers.ContractTransaction>;
-    createSubname: (args_0: {
-        name: string;
-        owner: string;
-        resolverAddress?: string | undefined;
-        contract: "nameWrapper" | "registry";
-        options?: {
-            addressOrIndex?: string | number | undefined;
-        } | undefined;
-    } | ({
-        contract: "nameWrapper";
-        fuses?: import("./@types/FuseOptions").FuseOptions | undefined;
-    } & {
-        name: string;
-        owner: string;
-        resolverAddress?: string | undefined;
-        contract: "nameWrapper" | "registry";
-        options?: {
-            addressOrIndex?: string | number | undefined;
-        } | undefined;
-    })) => Promise<ethers.ContractTransaction>;
-    deleteSubname: (name: string, contract: "nameWrapper" | "registry", options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    transferSubname: (name: string, contract: "nameWrapper" | "registry", address: string, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    getDNSOwner: (dnsName: string) => Promise<any>;
+    setName: WriteFunction<typeof import("./functions/setName").default>;
+    setRecords: WriteFunction<typeof import("./functions/setRecords").default>;
+    setRecord: WriteFunction<typeof import("./functions/setRecord").default>;
+    setResolver: WriteFunction<typeof import("./functions/setResolver").default>;
+    transferName: WriteFunction<typeof import("./functions/transferName").default>;
+    transferController: WriteFunction<typeof import("./functions/transferController").default>;
+    wrapName: WriteFunction<typeof import("./functions/wrapName").default>;
+    unwrapName: WriteFunction<typeof import("./functions/unwrapName").default>;
+    burnFuses: WriteFunction<typeof import("./functions/burnFuses").default>;
+    importDNSSECName: WriteFunction<typeof import("./functions/importDNSSECName").default>;
+    createSubname: WriteFunction<typeof import("./functions/createSubname").default>;
+    deleteSubname: WriteFunction<typeof import("./functions/deleteSubname").default>;
+    transferSubname: WriteFunction<typeof import("./functions/transferSubname").default>;
+    commitName: WriteFunction<typeof import("./functions/commitName").default>;
+    registerName: WriteFunction<typeof import("./functions/registerName").default>;
+    renewNames: WriteFunction<typeof import("./functions/renewNames").default>;
+    renewNameWithData: WriteFunction<typeof import("./functions/renewNames").renewNameWithData>;
 }
-export {};

package/dist/types/static.d.ts

@@ -0,0 +1,26 @@
+import type { StaticJsonRpcProvider } from '@ethersproject/providers/lib/url-json-rpc-provider';
+import { gql, GraphQLClient } from 'graphql-request';
+import { ENS, FunctionSubtype } from './index';
+import type Factories from './contracts/factories';
+import type FunctionTypes from './functions/types';
+declare type Options = ConstructorParameters<typeof ENS>[0] & {
+    functions: Partial<FunctionTypes>;
+    contracts: Partial<Factories>;
+};
+declare class StaticENS extends ENS {
+    private functions;
+    private contractsObject;
+    gqlInstance: {
+        client: GraphQLClient | {
+            request: () => Promise<null>;
+        };
+        setUrl: () => Promise<void>;
+        gql: typeof gql | ((query: TemplateStringsArray) => string);
+    };
+    constructor(provider: StaticJsonRpcProvider, { functions, contracts, ...options }: Options);
+    setStaticProvider: (provider: StaticJsonRpcProvider) => void;
+    setProvider: (provider: StaticJsonRpcProvider) => Promise<void>;
+    protected getModule: () => Promise<Partial<FunctionTypes>>;
+    protected getFunction: (subFunc: FunctionSubtype | undefined, _writeable: boolean | undefined, exportName: string, mod: any, path: string) => any;
+}
+export default StaticENS;

package/dist/types/utils/ccip.d.ts

@@ -0,0 +1,3 @@
+import type { BaseProvider, TransactionRequest } from '@ethersproject/providers';
+declare const ccipLookup: (provider: BaseProvider, transaction: TransactionRequest, result: string) => Promise<string | undefined>;
+export default ccipLookup;

package/dist/types/utils/consts.d.ts

@@ -0,0 +1 @@
+export declare const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";

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

@@ -0,0 +1,61 @@
+import { BigNumberish } from '@ethersproject/bignumber/lib/bignumber';
+export declare const fuseEnum: {
+    readonly CANNOT_UNWRAP: 1;
+    readonly CANNOT_BURN_FUSES: 2;
+    readonly CANNOT_TRANSFER: 4;
+    readonly CANNOT_SET_RESOLVER: 8;
+    readonly CANNOT_SET_TTL: 16;
+    readonly CANNOT_CREATE_SUBDOMAIN: 32;
+    readonly PARENT_CANNOT_CONTROL: 64;
+};
+export declare type FuseOptions = {
+    -readonly [K in keyof typeof fuseEnum]?: boolean;
+};
+export declare const unnamedFuses: readonly [128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296];
+declare const fullFuseEnum: {
+    CAN_DO_EVERYTHING: number;
+    CANNOT_UNWRAP: 1;
+    CANNOT_BURN_FUSES: 2;
+    CANNOT_TRANSFER: 4;
+    CANNOT_SET_RESOLVER: 8;
+    CANNOT_SET_TTL: 16;
+    CANNOT_CREATE_SUBDOMAIN: 32;
+    PARENT_CANNOT_CONTROL: 64;
+};
+export declare type FuseObj = typeof fuseEnum;
+export declare type CurrentFuses = {
+    [f in keyof FuseObj]: boolean;
+} & {
+    CAN_DO_EVERYTHING: boolean;
+};
+export declare type UnnamedFuseType = typeof unnamedFuses;
+export declare type Fuse = keyof FuseObj;
+export declare type UnnamedFuseValues = UnnamedFuseType[number];
+export declare type FuseArrayPossibilities = [Fuse] | [Fuse, Fuse] | [Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse] | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse];
+/**
+ * This type creates a type error if there are any duplicate fuses.
+ * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
+ *
+ * @template A The array to check for duplicates.
+ * @template B The union of all checked existing types.
+ */
+declare type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities ? A extends [infer Head, ...infer Tail] ? Head extends B ? [
+] : [
+    Head,
+    ...FusesWithoutDuplicates<Tail, Head | B>
+] : A : [
+];
+export declare type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>;
+export declare type FusePropsNamedArray = {
+    namedFusesToBurn: NamedFusesToBurn;
+};
+export declare type FusePropsUnnamedArray = {
+    unnamedFusesToBurn: UnnamedFuseValues[];
+};
+export declare type FusePropsNumber = {
+    fuseNumberToBurn: number;
+};
+export declare type FuseProps = (Partial<FusePropsNamedArray> & FusePropsUnnamedArray) | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
+export declare const validateFuses: (fuses: FuseProps) => number;
+export declare const decodeFuses: (fuses: BigNumberish) => CurrentFuses;
+export default fullFuseEnum;

package/dist/{cjs → types}/utils/generateFuseInput.d.ts

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