@ensdomains/ensjs 3.0.0-alpha.3 → 3.0.0-alpha.30

package/dist/types/generated/factories/TLDPublicSuffixList__factory.d.ts

@@ -0,0 +1,22 @@
+import { Signer } from "ethers";
+import type { Provider } from "@ethersproject/providers";
+import type { TLDPublicSuffixList, TLDPublicSuffixListInterface } from "../TLDPublicSuffixList";
+export declare class TLDPublicSuffixList__factory {
+    static readonly abi: {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+    }[];
+    static createInterface(): TLDPublicSuffixListInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): TLDPublicSuffixList;
+}

package/dist/types/generated/factories/index.d.ts

@@ -0,0 +1,21 @@
+export { BaseRegistrarImplementation__factory } from "./BaseRegistrarImplementation__factory";
+export { BulkRenewal__factory } from "./BulkRenewal__factory";
+export { DNSRegistrar__factory } from "./DNSRegistrar__factory";
+export { DNSSECImpl__factory } from "./DNSSECImpl__factory";
+export { DefaultReverseResolver__factory } from "./DefaultReverseResolver__factory";
+export { ENSRegistry__factory } from "./ENSRegistry__factory";
+export { ETHRegistrarController__factory } from "./ETHRegistrarController__factory";
+export { Multicall__factory } from "./Multicall__factory";
+export { NameWrapper__factory } from "./NameWrapper__factory";
+export { P256SHA256Algorithm__factory } from "./P256SHA256Algorithm__factory";
+export { PublicResolver__factory } from "./PublicResolver__factory";
+export { RSASHA1Algorithm__factory } from "./RSASHA1Algorithm__factory";
+export { RSASHA256Algorithm__factory } from "./RSASHA256Algorithm__factory";
+export { ReverseRegistrar__factory } from "./ReverseRegistrar__factory";
+export { Root__factory } from "./Root__factory";
+export { SHA1Digest__factory } from "./SHA1Digest__factory";
+export { SHA1NSEC3Digest__factory } from "./SHA1NSEC3Digest__factory";
+export { SHA256Digest__factory } from "./SHA256Digest__factory";
+export { StaticMetadataService__factory } from "./StaticMetadataService__factory";
+export { TLDPublicSuffixList__factory } from "./TLDPublicSuffixList__factory";
+export { UniversalResolver__factory } from "./UniversalResolver__factory";

package/dist/types/generated/index.d.ts

@@ -0,0 +1,43 @@
+export type { BaseRegistrarImplementation } from "./BaseRegistrarImplementation";
+export type { BulkRenewal } from "./BulkRenewal";
+export type { DNSRegistrar } from "./DNSRegistrar";
+export type { DNSSECImpl } from "./DNSSECImpl";
+export type { DefaultReverseResolver } from "./DefaultReverseResolver";
+export type { ENSRegistry } from "./ENSRegistry";
+export type { ETHRegistrarController } from "./ETHRegistrarController";
+export type { Multicall } from "./Multicall";
+export type { NameWrapper } from "./NameWrapper";
+export type { P256SHA256Algorithm } from "./P256SHA256Algorithm";
+export type { PublicResolver } from "./PublicResolver";
+export type { RSASHA1Algorithm } from "./RSASHA1Algorithm";
+export type { RSASHA256Algorithm } from "./RSASHA256Algorithm";
+export type { ReverseRegistrar } from "./ReverseRegistrar";
+export type { Root } from "./Root";
+export type { SHA1Digest } from "./SHA1Digest";
+export type { SHA1NSEC3Digest } from "./SHA1NSEC3Digest";
+export type { SHA256Digest } from "./SHA256Digest";
+export type { StaticMetadataService } from "./StaticMetadataService";
+export type { TLDPublicSuffixList } from "./TLDPublicSuffixList";
+export type { UniversalResolver } from "./UniversalResolver";
+export * as factories from "./factories";
+export { BaseRegistrarImplementation__factory } from "./factories/BaseRegistrarImplementation__factory";
+export { DefaultReverseResolver__factory } from "./factories/DefaultReverseResolver__factory";
+export { DNSRegistrar__factory } from "./factories/DNSRegistrar__factory";
+export { DNSSECImpl__factory } from "./factories/DNSSECImpl__factory";
+export { ENSRegistry__factory } from "./factories/ENSRegistry__factory";
+export { ETHRegistrarController__factory } from "./factories/ETHRegistrarController__factory";
+export { P256SHA256Algorithm__factory } from "./factories/P256SHA256Algorithm__factory";
+export { PublicResolver__factory } from "./factories/PublicResolver__factory";
+export { ReverseRegistrar__factory } from "./factories/ReverseRegistrar__factory";
+export { Root__factory } from "./factories/Root__factory";
+export { RSASHA1Algorithm__factory } from "./factories/RSASHA1Algorithm__factory";
+export { RSASHA256Algorithm__factory } from "./factories/RSASHA256Algorithm__factory";
+export { SHA1Digest__factory } from "./factories/SHA1Digest__factory";
+export { SHA1NSEC3Digest__factory } from "./factories/SHA1NSEC3Digest__factory";
+export { SHA256Digest__factory } from "./factories/SHA256Digest__factory";
+export { TLDPublicSuffixList__factory } from "./factories/TLDPublicSuffixList__factory";
+export { Multicall__factory } from "./factories/Multicall__factory";
+export { NameWrapper__factory } from "./factories/NameWrapper__factory";
+export { StaticMetadataService__factory } from "./factories/StaticMetadataService__factory";
+export { UniversalResolver__factory } from "./factories/UniversalResolver__factory";
+export { BulkRenewal__factory } from "./factories/BulkRenewal__factory";

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

@@ -1,8 +1,26 @@
-import { ethers } from 'ethers';
-import ContractManager from './contracts';
+import type { JsonRpcSigner } from '@ethersproject/providers';
+import { ContractTransaction, ethers, PopulatedTransaction } from 'ethers';
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
+import ContractManager from './contracts/index';
 import { SupportedNetworkId } from './contracts/types';
+import type burnFuses from './functions/burnFuses';
+import type commitName from './functions/commitName';
+import type createSubname from './functions/createSubname';
+import type deleteSubname from './functions/deleteSubname';
+import type registerName from './functions/registerName';
+import type { default as renewNames, renewNameWithData } from './functions/renewNames';
+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 transferController from './functions/transferController';
+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';
+import importDNSSECName from './functions/importDNSSECName';
+export type { Fuse, FuseArrayPossibilities, FuseObj, NamedFusesToBurn, UnnamedFuseType, UnnamedFuseValues, } from './utils/fuses';
 declare type ENSOptions = {
     graphURI?: string | null;
     getContractAddress?: typeof _getContractAddress;
@@ -10,6 +28,7 @@ declare type ENSOptions = {
 export declare type InternalENS = {
     options?: ENSOptions;
     provider?: ethers.providers.Provider;
+    signer: JsonRpcSigner;
     graphURI?: string | null;
 } & ENS;
 export declare type ENSArgs<K extends keyof InternalENS> = {
@@ -17,6 +36,17 @@ 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 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 type RawFunction = {
     raw: (...args: any[]) => Promise<{
         to: string;
@@ -77,6 +107,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
@@ -104,11 +142,18 @@ export declare class ENS {
         }>;
         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;
@@ -137,6 +182,7 @@ export declare class ENS {
         contentHash?: boolean | undefined;
         texts?: boolean | string[] | undefined;
         coinTypes?: boolean | string[] | undefined;
+        resolverAddress?: string | undefined;
     } | undefined) => Promise<{
         isMigrated: boolean | null;
         createdAt: string | null;
@@ -173,8 +219,8 @@ export declare class ENS {
             reverseResolverAddress: any;
             resolverAddress: any;
         } | {
-            name: null;
-            match: boolean;
+            name: undefined;
+            match?: undefined;
             reverseResolverAddress?: undefined;
             resolverAddress?: undefined;
         } | undefined>;
@@ -186,73 +232,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;
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
+            fuseObj: import("./utils/fuses").CurrentFuses;
+            expiryDate: Date;
             rawFuses: ethers.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" | "FusesSet" | "NameUnwrapped" | "NameWrapped" | "NewOwner" | "NewResolver" | "NewTTL" | "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;
@@ -337,11 +351,18 @@ export declare class ENS {
         } | 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 +373,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 +391,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 +401,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 +411,16 @@ 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<{
+        decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, _nameOrNames: string | string[], _duration: number, legacy?: boolean | undefined) => Promise<{
             base: ethers.BigNumber;
             premium: ethers.BigNumber;
         } | undefined>;
     }>;
+    getDNSOwner: (dnsName: string) => Promise<any>;
     universalWrapper: GeneratedRawFunction<{
         raw: ({ contracts }: ENSArgs<"contracts">, name: string, data: string) => Promise<{
             to: string;
@@ -417,55 +442,84 @@ export declare class ENS {
         decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<ethers.utils.Result | undefined>;
     }>;
     multicallWrapper: GeneratedRawFunction<{
-        raw: ({ contracts }: ENSArgs<"contracts">, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean) => Promise<{
+        raw({ contracts }: ENSArgs<"contracts">, transactions: ethers.providers.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: ethers.providers.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: () => Promise<any>;
+    setName: WriteFunction<typeof setName>;
+    setRecords: WriteFunction<typeof setRecords>;
+    setRecord: WriteFunction<typeof setRecord>;
+    setResolver: WriteFunction<typeof setResolver>;
+    transferName: WriteFunction<typeof transferName>;
+    transferController: WriteFunction<typeof transferController>;
+    wrapName: WriteFunction<typeof wrapName>;
+    unwrapName: WriteFunction<typeof unwrapName>;
+    burnFuses: WriteFunction<typeof burnFuses>;
+    importDNSSECName: WriteFunction<typeof importDNSSECName>;
+    createSubname: WriteFunction<typeof createSubname>;
+    deleteSubname: WriteFunction<typeof deleteSubname>;
+    transferSubname: WriteFunction<typeof transferSubname>;
+    commitName: WriteFunction<typeof commitName>;
+    registerName: WriteFunction<typeof registerName>;
+    renewNames: WriteFunction<typeof renewNames>;
+    renewNameWithData: WriteFunction<typeof renewNameWithData>;
 }
-export {};

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,58 @@
+import { BigNumberish } from 'ethers';
+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 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/types/utils/normalise.d.ts

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

package/dist/{esm → types}/utils/recordHelpers.d.ts

@@ -4,10 +4,14 @@ declare type RecordItem = {
     value: string;
 };
 export declare type RecordOptions = {
+    clearRecords?: boolean;
     contentHash?: string;
     texts?: RecordItem[];
     coinTypes?: RecordItem[];
 };
 export declare const generateSetAddr: (namehash: string, coinType: string, address: string, resolver: PublicResolver) => string;
+export declare type RecordTypes = 'contentHash' | 'text' | 'addr';
+export declare type RecordInput<T extends RecordTypes> = T extends 'contentHash' ? string : RecordItem;
+export declare function generateSingleRecordCall<T extends RecordTypes>(namehash: string, resolver: PublicResolver, type: T): (record: RecordInput<T>) => string;
 export declare const generateRecordCallArray: (namehash: string, records: RecordOptions, resolver: PublicResolver) => string[];
 export {};