@ensdomains/ensjs 3.0.0-alpha.41 → 3.0.0-alpha.42

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

@@ -1,4 +1,4 @@
-import type { FunctionFragment, Result } from '@ethersproject/abi';
+import type { EventFragment, FunctionFragment, Result } from '@ethersproject/abi';
 import { Interface } from '@ethersproject/abi';
 import type { Listener, Provider } from '@ethersproject/abstract-provider';
 import type { Signer } from '@ethersproject/abstract-signer';
@@ -11,7 +11,9 @@ export interface UniversalResolverInterface extends Interface {
         '_resolveSingle(bytes,bytes,string[],bytes4,bytes)': FunctionFragment;
         'batchGatewayURLs(uint256)': FunctionFragment;
         'findResolver(bytes)': FunctionFragment;
+        'owner()': FunctionFragment;
         'registry()': FunctionFragment;
+        'renounceOwnership()': FunctionFragment;
         'resolve(bytes,bytes,string[])': FunctionFragment;
         'resolve(bytes,bytes[])': FunctionFragment;
         'resolve(bytes,bytes[],string[])': FunctionFragment;
@@ -21,9 +23,11 @@ export interface UniversalResolverInterface extends Interface {
         'reverse(bytes,string[])': FunctionFragment;
         'reverse(bytes)': FunctionFragment;
         'reverseCallback(bytes,bytes)': FunctionFragment;
+        'setGatewayURLs(string[])': FunctionFragment;
         'supportsInterface(bytes4)': FunctionFragment;
+        'transferOwnership(address)': FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: '_resolveSingle' | 'batchGatewayURLs' | 'findResolver' | 'registry' | 'resolve(bytes,bytes,string[])' | 'resolve(bytes,bytes[])' | 'resolve(bytes,bytes[],string[])' | 'resolve(bytes,bytes)' | 'resolveCallback' | 'resolveSingleCallback' | 'reverse(bytes,string[])' | 'reverse(bytes)' | 'reverseCallback' | 'supportsInterface'): FunctionFragment;
+    getFunction(nameOrSignatureOrTopic: '_resolveSingle' | 'batchGatewayURLs' | 'findResolver' | 'owner' | 'registry' | 'renounceOwnership' | 'resolve(bytes,bytes,string[])' | 'resolve(bytes,bytes[])' | 'resolve(bytes,bytes[],string[])' | 'resolve(bytes,bytes)' | 'resolveCallback' | 'resolveSingleCallback' | 'reverse(bytes,string[])' | 'reverse(bytes)' | 'reverseCallback' | 'setGatewayURLs' | 'supportsInterface' | 'transferOwnership'): FunctionFragment;
     encodeFunctionData(functionFragment: '_resolveSingle', values: [
         PromiseOrValue<BytesLike>,
         PromiseOrValue<BytesLike>,
@@ -33,7 +37,9 @@ export interface UniversalResolverInterface extends Interface {
     ]): string;
     encodeFunctionData(functionFragment: 'batchGatewayURLs', values: [PromiseOrValue<BigNumberish>]): string;
     encodeFunctionData(functionFragment: 'findResolver', values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: 'owner', values?: undefined): string;
     encodeFunctionData(functionFragment: 'registry', values?: undefined): string;
+    encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string;
     encodeFunctionData(functionFragment: 'resolve(bytes,bytes,string[])', values: [
         PromiseOrValue<BytesLike>,
         PromiseOrValue<BytesLike>,
@@ -51,11 +57,15 @@ export interface UniversalResolverInterface extends Interface {
     encodeFunctionData(functionFragment: 'reverse(bytes,string[])', values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>[]]): string;
     encodeFunctionData(functionFragment: 'reverse(bytes)', values: [PromiseOrValue<BytesLike>]): string;
     encodeFunctionData(functionFragment: 'reverseCallback', values: [PromiseOrValue<BytesLike>, PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: 'setGatewayURLs', values: [PromiseOrValue<string>[]]): string;
     encodeFunctionData(functionFragment: 'supportsInterface', values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: 'transferOwnership', values: [PromiseOrValue<string>]): string;
     decodeFunctionResult(functionFragment: '_resolveSingle', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'batchGatewayURLs', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'findResolver', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'registry', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'resolve(bytes,bytes,string[])', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'resolve(bytes,bytes[])', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'resolve(bytes,bytes[],string[])', data: BytesLike): Result;
@@ -65,9 +75,23 @@ export interface UniversalResolverInterface extends Interface {
     decodeFunctionResult(functionFragment: 'reverse(bytes,string[])', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'reverse(bytes)', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'reverseCallback', data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: 'setGatewayURLs', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'supportsInterface', data: BytesLike): Result;
-    events: {};
+    decodeFunctionResult(functionFragment: 'transferOwnership', data: BytesLike): Result;
+    events: {
+        'OwnershipTransferred(address,address)': EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment;
+}
+export interface OwnershipTransferredEventObject {
+    previousOwner: string;
+    newOwner: string;
 }
+export declare type OwnershipTransferredEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferredEventObject>;
+export declare type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
 export interface UniversalResolver extends BaseContract {
     connect(signerOrProvider: Signer | Provider | string): this;
     attach(addressOrName: string): this;
@@ -86,49 +110,59 @@ export interface UniversalResolver extends BaseContract {
         _resolveSingle(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], callbackFunction: PromiseOrValue<BytesLike>, metaData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string]>;
         batchGatewayURLs(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
         findResolver(name: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string]>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
         registry(overrides?: CallOverrides): Promise<[string]>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
         'resolve(bytes,bytes,string[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<[string, string]>;
         'resolve(bytes,bytes[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<[string[], string]>;
         'resolve(bytes,bytes[],string[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<[string[], string]>;
         'resolve(bytes,bytes)'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string]>;
-        resolveCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
-            from?: PromiseOrValue<string>;
-        }): Promise<ContractTransaction>;
-        resolveSingleCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
-            from?: PromiseOrValue<string>;
-        }): Promise<ContractTransaction>;
+        resolveCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string[], string]>;
+        resolveSingleCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string]>;
         'reverse(bytes,string[])'(reverseName: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<[string, string, string, string]>;
         'reverse(bytes)'(reverseName: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string, string, string]>;
-        reverseCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        reverseCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string, string, string]>;
+        setGatewayURLs(_urls: PromiseOrValue<string>[], overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
         supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean]>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
     };
     _resolveSingle(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], callbackFunction: PromiseOrValue<BytesLike>, metaData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string]>;
     batchGatewayURLs(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
     findResolver(name: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string]>;
+    owner(overrides?: CallOverrides): Promise<string>;
     registry(overrides?: CallOverrides): Promise<string>;
+    renounceOwnership(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
     'resolve(bytes,bytes,string[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<[string, string]>;
     'resolve(bytes,bytes[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<[string[], string]>;
     'resolve(bytes,bytes[],string[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<[string[], string]>;
     'resolve(bytes,bytes)'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string]>;
-    resolveCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
-        from?: PromiseOrValue<string>;
-    }): Promise<ContractTransaction>;
-    resolveSingleCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
-        from?: PromiseOrValue<string>;
-    }): Promise<ContractTransaction>;
+    resolveCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string[], string]>;
+    resolveSingleCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string]>;
     'reverse(bytes,string[])'(reverseName: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<[string, string, string, string]>;
     'reverse(bytes)'(reverseName: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string, string, string]>;
-    reverseCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+    reverseCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string, string, string]>;
+    setGatewayURLs(_urls: PromiseOrValue<string>[], overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
     supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
     callStatic: {
         _resolveSingle(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], callbackFunction: PromiseOrValue<BytesLike>, metaData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string]>;
         batchGatewayURLs(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
         findResolver(name: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string]>;
+        owner(overrides?: CallOverrides): Promise<string>;
         registry(overrides?: CallOverrides): Promise<string>;
+        renounceOwnership(overrides?: CallOverrides): Promise<void>;
         'resolve(bytes,bytes,string[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<[string, string]>;
         'resolve(bytes,bytes[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<[string[], string]>;
         'resolve(bytes,bytes[],string[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<[string[], string]>;
@@ -138,51 +172,64 @@ export interface UniversalResolver extends BaseContract {
         'reverse(bytes,string[])'(reverseName: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<[string, string, string, string]>;
         'reverse(bytes)'(reverseName: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string, string, string]>;
         reverseCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string, string, string]>;
+        setGatewayURLs(_urls: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<void>;
         supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        'OwnershipTransferred(address,address)'(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+        OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
     };
-    filters: {};
     estimateGas: {
         _resolveSingle(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], callbackFunction: PromiseOrValue<BytesLike>, metaData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
         batchGatewayURLs(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
         findResolver(name: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
         registry(overrides?: CallOverrides): Promise<BigNumber>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
         'resolve(bytes,bytes,string[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<BigNumber>;
         'resolve(bytes,bytes[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<BigNumber>;
         'resolve(bytes,bytes[],string[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<BigNumber>;
         'resolve(bytes,bytes)'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
-        resolveCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
-            from?: PromiseOrValue<string>;
-        }): Promise<BigNumber>;
-        resolveSingleCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
-            from?: PromiseOrValue<string>;
-        }): Promise<BigNumber>;
+        resolveCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        resolveSingleCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
         'reverse(bytes,string[])'(reverseName: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<BigNumber>;
         'reverse(bytes)'(reverseName: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
-        reverseCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        reverseCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        setGatewayURLs(_urls: PromiseOrValue<string>[], overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
         supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
     };
     populateTransaction: {
         _resolveSingle(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], callbackFunction: PromiseOrValue<BytesLike>, metaData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         batchGatewayURLs(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         findResolver(name: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         registry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
         'resolve(bytes,bytes,string[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
         'resolve(bytes,bytes[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
         'resolve(bytes,bytes[],string[])'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
         'resolve(bytes,bytes)'(name: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        resolveCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
-            from?: PromiseOrValue<string>;
-        }): Promise<PopulatedTransaction>;
-        resolveSingleCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
-            from?: PromiseOrValue<string>;
-        }): Promise<PopulatedTransaction>;
+        resolveCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        resolveSingleCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         'reverse(bytes,string[])'(reverseName: PromiseOrValue<BytesLike>, gateways: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
         'reverse(bytes)'(reverseName: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        reverseCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        reverseCallback(response: PromiseOrValue<BytesLike>, extraData: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        setGatewayURLs(_urls: PromiseOrValue<string>[], overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
         supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
     };
 }

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

@@ -11,6 +11,7 @@ export declare class UniversalResolver__factory {
         stateMutability: string;
         type: string;
         name?: undefined;
+        anonymous?: undefined;
         outputs?: undefined;
     } | {
         inputs: {
@@ -21,6 +22,19 @@ export declare class UniversalResolver__factory {
         name: string;
         type: string;
         stateMutability?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
         outputs?: undefined;
     } | {
         inputs: {
@@ -36,6 +50,7 @@ export declare class UniversalResolver__factory {
         }[];
         stateMutability: string;
         type: string;
+        anonymous?: undefined;
     })[];
     static createInterface(): UniversalResolverInterface;
     static connect(address: string, signerOrProvider: Signer | Provider): UniversalResolver;

package/dist/types/index.d.ts

@@ -4,7 +4,7 @@ import { getContractAddress as _getContractAddress } from './contracts/getContra
 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';
+export type { ChildFuses, ParentFuses } from './utils/fuses';
 declare type ENSOptions = {
     graphURI?: string | null;
     getContractAddress?: typeof _getContractAddress;
@@ -236,15 +236,55 @@ export declare class ENS {
             data: string;
         }>;
         decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
-            fuseObj: import("./utils/fuses").CurrentFuses;
-            expiryDate: Date;
-            rawFuses: import("ethers").BigNumber;
-            owner: any;
+            expiryDate: Date | undefined;
+            rawFuses: number;
+            owner: string;
+            parent: {
+                unnamed: {
+                    524288: boolean;
+                    1048576: boolean;
+                    2097152: boolean;
+                    4194304: boolean;
+                    8388608: boolean;
+                    16777216: boolean;
+                    33554432: boolean;
+                    67108864: boolean;
+                    134217728: boolean;
+                    268435456: boolean;
+                    536870912: boolean;
+                    1073741824: boolean;
+                    2147483648: boolean;
+                };
+                IS_DOT_ETH: boolean;
+                PARENT_CANNOT_CONTROL: boolean;
+                CAN_EXTEND_EXPIRY: boolean;
+            };
+            child: {
+                CAN_DO_EVERYTHING: boolean;
+                unnamed: {
+                    1024: boolean;
+                    64: boolean;
+                    128: boolean;
+                    256: boolean;
+                    512: boolean;
+                    2048: boolean;
+                    4096: boolean;
+                    8192: boolean;
+                    16384: boolean;
+                    32768: boolean;
+                };
+                CANNOT_UNWRAP: boolean;
+                CANNOT_BURN_FUSES: boolean;
+                CANNOT_TRANSFER: boolean;
+                CANNOT_SET_RESOLVER: boolean;
+                CANNOT_SET_TTL: boolean;
+                CANNOT_CREATE_SUBDOMAIN: boolean;
+            };
         } | undefined>;
     }>;
     getHistory: (name: string) => Promise<{
         domain: {
-            type: "Transfer" | "NewOwner" | "NewResolver" | "NewTTL" | "FusesSet" | "NameUnwrapped" | "NameWrapped" | "WrappedTransfer";
+            type: "Transfer" | "NewOwner" | "NewResolver" | "NewTTL" | "ExpiryExtended" | "FusesSet" | "NameUnwrapped" | "NameWrapped" | "WrappedTransfer";
             blockNumber: number;
             transactionHash: string;
             id: string;
@@ -368,6 +408,7 @@ export declare class ENS {
             registrant?: string | undefined;
             owner?: string | undefined;
             ownershipLevel: "nameWrapper" | "registrar" | "registry";
+            expired?: boolean | undefined;
         } | undefined>;
     }>;
     getExpiry: GeneratedRawFunction<{
@@ -423,7 +464,7 @@ export declare class ENS {
         orderBy?: "labelName" | "createdAt" | undefined;
     } | {
         type: "wrappedOwner";
-        orderBy?: "expiryDate" | "labelName" | undefined;
+        orderBy?: "name" | "expiryDate" | undefined;
     } | {
         type: "all";
         orderBy?: "labelName" | "creationDate" | undefined;
@@ -541,7 +582,8 @@ export declare class ENS {
     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>;
+    setFuses: WriteFunction<typeof import("./functions/setFuses").default>;
+    setChildFuses: WriteFunction<typeof import("./functions/setFuses").setChildFuses>;
     importDNSSECName: WriteFunction<typeof import("./functions/importDNSSECName").default>;
     createSubname: WriteFunction<typeof import("./functions/createSubname").default>;
     deleteSubname: WriteFunction<typeof import("./functions/deleteSubname").default>;
@@ -549,5 +591,5 @@ export declare class ENS {
     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>;
+    extendWrappedName: WriteFunction<typeof import("./functions/renewNames").extendWrappedName>;
 }

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

@@ -1 +1,2 @@
 export declare const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const MAX_INT_64: bigint;

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

@@ -1,61 +1,131 @@
-import { BigNumberish } from '@ethersproject/bignumber/lib/bignumber';
-export declare const fuseEnum: {
+export declare const CHILD_CONTROLLED_FUSES = 65535;
+export declare const PARENT_CONTROLLED_FUSES = 4294901760;
+export declare const USER_SETTABLE_FUSES = 4294836223;
+export declare const childFuseEnum: {
     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 parentFuseEnum: {
+    PARENT_CANNOT_CONTROL: number;
+    CAN_EXTEND_EXPIRY: number;
 };
-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: {
+export declare const fullParentFuseEnum: {
+    readonly IS_DOT_ETH: 131072;
+    readonly PARENT_CANNOT_CONTROL: number;
+    readonly CAN_EXTEND_EXPIRY: number;
+};
+export declare const userSettableFuseEnum: {
+    readonly PARENT_CANNOT_CONTROL: number;
+    readonly CAN_EXTEND_EXPIRY: number;
+    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;
+};
+export declare const fullFuseEnum: {
     CAN_DO_EVERYTHING: number;
+    PARENT_CANNOT_CONTROL: number;
+    CAN_EXTEND_EXPIRY: 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 declare const unnamedChildFuses: readonly [64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768];
+export declare const unnamedParentFuses: readonly [524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648];
+export declare const unnamedUserSettableFuses: readonly [64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648];
+export declare const childFuseKeys: ("CANNOT_UNWRAP" | "CANNOT_BURN_FUSES" | "CANNOT_TRANSFER" | "CANNOT_SET_RESOLVER" | "CANNOT_SET_TTL" | "CANNOT_CREATE_SUBDOMAIN")[];
+export declare const parentFuseKeys: ("PARENT_CANNOT_CONTROL" | "CAN_EXTEND_EXPIRY")[];
+export declare const fullParentFuseKeys: ("PARENT_CANNOT_CONTROL" | "CAN_EXTEND_EXPIRY" | "IS_DOT_ETH")[];
+export declare const userSettableFuseKeys: ("CANNOT_UNWRAP" | "CANNOT_BURN_FUSES" | "CANNOT_TRANSFER" | "CANNOT_SET_RESOLVER" | "CANNOT_SET_TTL" | "CANNOT_CREATE_SUBDOMAIN" | "PARENT_CANNOT_CONTROL" | "CAN_EXTEND_EXPIRY")[];
+declare type FuseType<Enum extends Record<string, number>, UnnamedTuple extends readonly number[], CustomFuses extends string = never> = {
+    fuse: keyof Enum;
+    options: {
+        -readonly [K in keyof Enum]?: boolean;
+    };
+    current: {
+        [K in keyof Enum]: boolean;
+    } & {
+        readonly [K in CustomFuses]: boolean;
+    };
+    unnamed: UnnamedTuple;
+    unnamedValues: UnnamedTuple[number];
+    unnamedObject: {
+        [K in UnnamedTuple[number]]: boolean;
+    };
+};
+export declare type ChildFuses = FuseType<typeof childFuseEnum, typeof unnamedChildFuses, 'CAN_DO_EVERYTHING'>;
+export declare type ParentFuses = FuseType<typeof parentFuseEnum, typeof unnamedParentFuses>;
+export declare type FullParentFuses = FuseType<typeof fullParentFuseEnum, typeof unnamedParentFuses>;
+export declare type UserSettableFuses = FuseType<typeof userSettableFuseEnum, typeof unnamedUserSettableFuses>;
+declare type InputFuses<NamedFuse extends string, UnnamedFuse extends number> = {
+    named: readonly NamedFuse[];
+} | {
+    unnamed: readonly UnnamedFuse[];
+} | {
+    named: readonly NamedFuse[];
+    unnamed: readonly UnnamedFuse[];
+} | {
+    number: number;
+};
+export declare type CombinedFuseInput = {
+    child: InputFuses<ChildFuses['fuse'], ChildFuses['unnamedValues']>;
+    parent: InputFuses<ParentFuses['fuse'], ParentFuses['unnamedValues']>;
+};
+export declare const hasFuses: (fuses: any) => boolean;
+export declare function encodeFuses(fuses: Partial<CombinedFuseInput> | number): number;
+export declare function encodeFuses(fuses: CombinedFuseInput['child'], restrictTo: 'child'): number;
+export declare function encodeFuses(fuses: CombinedFuseInput['parent'], restrictTo: 'parent'): number;
+export declare const decodeFuses: (fuses: number) => {
+    parent: {
+        unnamed: {
+            524288: boolean;
+            1048576: boolean;
+            2097152: boolean;
+            4194304: boolean;
+            8388608: boolean;
+            16777216: boolean;
+            33554432: boolean;
+            67108864: boolean;
+            134217728: boolean;
+            268435456: boolean;
+            536870912: boolean;
+            1073741824: boolean;
+            2147483648: boolean;
+        };
+        IS_DOT_ETH: boolean;
+        PARENT_CANNOT_CONTROL: boolean;
+        CAN_EXTEND_EXPIRY: boolean;
+    };
+    child: {
+        CAN_DO_EVERYTHING: boolean;
+        unnamed: {
+            1024: boolean;
+            64: boolean;
+            128: boolean;
+            256: boolean;
+            512: boolean;
+            2048: boolean;
+            4096: boolean;
+            8192: boolean;
+            16384: boolean;
+            32768: boolean;
+        };
+        CANNOT_UNWRAP: boolean;
+        CANNOT_BURN_FUSES: boolean;
+        CANNOT_TRANSFER: boolean;
+        CANNOT_SET_RESOLVER: boolean;
+        CANNOT_SET_TTL: boolean;
+        CANNOT_CREATE_SUBDOMAIN: boolean;
+    };
+};
+export declare type AllCurrentFuses = ReturnType<typeof decodeFuses>;
 export default fullFuseEnum;

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

@@ -1,8 +1,6 @@
-import { BigNumberish } from '@ethersproject/bignumber/lib/bignumber';
 import type { PublicResolver } from '../generated';
-import { FuseOptions } from './fuses';
+import { CombinedFuseInput } from './fuses';
 import { RecordOptions } from './recordHelpers';
-export declare const MAX_INT_64: bigint;
 export declare type BaseRegistrationParams = {
     owner: string;
     duration: number;
@@ -10,16 +8,14 @@ export declare type BaseRegistrationParams = {
     resolverAddress?: string;
     records?: RecordOptions;
     reverseRecord?: boolean;
-    fuses?: FuseOptions;
-    wrapperExpiry?: BigNumberish;
+    fuses?: CombinedFuseInput['child'];
 };
 export declare type RegistrationParams = Omit<BaseRegistrationParams, 'resolverAddress'> & {
     name: string;
     resolver: PublicResolver;
 };
-export declare type CommitmentParams = Omit<RegistrationParams, 'secret' | 'wrapperExpiry'> & {
+export declare type CommitmentParams = Omit<RegistrationParams, 'secret'> & {
     secret?: string;
-    wrapperExpiry?: BigNumberish;
 };
 export declare type RegistrationTuple = [
     name: string,
@@ -29,31 +25,17 @@ export declare type RegistrationTuple = [
     resolver: string,
     data: string[],
     reverseRecord: boolean,
-    fuses: string,
-    wrapperExpiry: BigNumberish
-];
-export declare type CommitmentTuple = [
-    labelhash: string,
-    owner: string,
-    duration: number,
-    resolver: string,
-    data: string[],
-    secret: string,
-    reverseRecord: boolean,
-    fuses: string,
-    wrapperExpiry: BigNumberish
+    ownerControlledFuses: number
 ];
 export declare const randomSecret: () => string;
-export declare const makeCommitmentData: ({ name, owner, duration, resolver, records, reverseRecord, fuses, wrapperExpiry, secret, }: Omit<RegistrationParams, "secret" | "wrapperExpiry"> & {
+export declare const makeCommitmentData: ({ name, owner, duration, resolver, records, reverseRecord, fuses, secret, }: Omit<RegistrationParams, "secret"> & {
     secret?: string | undefined;
-    wrapperExpiry?: BigNumberish | undefined;
 } & {
     secret: string;
-}) => CommitmentTuple;
+}) => RegistrationTuple;
 export declare const makeRegistrationData: (params: RegistrationParams) => RegistrationTuple;
-export declare const _makeCommitment: (params: CommitmentTuple) => string;
+export declare const _makeCommitment: (params: RegistrationTuple) => string;
 export declare const makeCommitment: ({ secret, ...inputParams }: CommitmentParams) => {
     secret: string;
     commitment: string;
-    wrapperExpiry: BigNumberish;
 };