@ensdomains/ensjs 3.0.0-alpha.21 → 3.0.0-alpha.23

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

@@ -7,15 +7,17 @@ export interface PublicResolverInterface extends utils.Interface {
         "ABI(bytes32,uint256)": FunctionFragment;
         "addr(bytes32)": FunctionFragment;
         "addr(bytes32,uint256)": FunctionFragment;
-        "clearDNSZone(bytes32)": FunctionFragment;
+        "clearRecords(bytes32)": FunctionFragment;
         "contenthash(bytes32)": FunctionFragment;
         "dnsRecord(bytes32,bytes32,uint16)": FunctionFragment;
         "hasDNSRecords(bytes32,bytes32)": FunctionFragment;
         "interfaceImplementer(bytes32,bytes4)": FunctionFragment;
         "isApprovedForAll(address,address)": FunctionFragment;
         "multicall(bytes[])": FunctionFragment;
+        "multicallWithNodeCheck(bytes32,bytes[])": FunctionFragment;
         "name(bytes32)": FunctionFragment;
         "pubkey(bytes32)": FunctionFragment;
+        "recordVersions(bytes32)": FunctionFragment;
         "setABI(bytes32,uint256,bytes)": FunctionFragment;
         "setAddr(bytes32,uint256,bytes)": FunctionFragment;
         "setAddr(bytes32,address)": FunctionFragment;
@@ -31,11 +33,11 @@ export interface PublicResolverInterface extends utils.Interface {
         "text(bytes32,string)": FunctionFragment;
         "zonehash(bytes32)": FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: "ABI" | "addr(bytes32)" | "addr(bytes32,uint256)" | "clearDNSZone" | "contenthash" | "dnsRecord" | "hasDNSRecords" | "interfaceImplementer" | "isApprovedForAll" | "multicall" | "name" | "pubkey" | "setABI" | "setAddr(bytes32,uint256,bytes)" | "setAddr(bytes32,address)" | "setApprovalForAll" | "setContenthash" | "setDNSRecords" | "setInterface" | "setName" | "setPubkey" | "setText" | "setZonehash" | "supportsInterface" | "text" | "zonehash"): FunctionFragment;
+    getFunction(nameOrSignatureOrTopic: "ABI" | "addr(bytes32)" | "addr(bytes32,uint256)" | "clearRecords" | "contenthash" | "dnsRecord" | "hasDNSRecords" | "interfaceImplementer" | "isApprovedForAll" | "multicall" | "multicallWithNodeCheck" | "name" | "pubkey" | "recordVersions" | "setABI" | "setAddr(bytes32,uint256,bytes)" | "setAddr(bytes32,address)" | "setApprovalForAll" | "setContenthash" | "setDNSRecords" | "setInterface" | "setName" | "setPubkey" | "setText" | "setZonehash" | "supportsInterface" | "text" | "zonehash"): FunctionFragment;
     encodeFunctionData(functionFragment: "ABI", values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]): string;
     encodeFunctionData(functionFragment: "addr(bytes32)", values: [PromiseOrValue<BytesLike>]): string;
     encodeFunctionData(functionFragment: "addr(bytes32,uint256)", values: [PromiseOrValue<BytesLike>, PromiseOrValue<BigNumberish>]): string;
-    encodeFunctionData(functionFragment: "clearDNSZone", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "clearRecords", values: [PromiseOrValue<BytesLike>]): string;
     encodeFunctionData(functionFragment: "contenthash", values: [PromiseOrValue<BytesLike>]): string;
     encodeFunctionData(functionFragment: "dnsRecord", values: [
         PromiseOrValue<BytesLike>,
@@ -46,8 +48,10 @@ export interface PublicResolverInterface extends utils.Interface {
     encodeFunctionData(functionFragment: "interfaceImplementer", values: [PromiseOrValue<BytesLike>, PromiseOrValue<BytesLike>]): string;
     encodeFunctionData(functionFragment: "isApprovedForAll", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
     encodeFunctionData(functionFragment: "multicall", values: [PromiseOrValue<BytesLike>[]]): string;
+    encodeFunctionData(functionFragment: "multicallWithNodeCheck", values: [PromiseOrValue<BytesLike>, PromiseOrValue<BytesLike>[]]): string;
     encodeFunctionData(functionFragment: "name", values: [PromiseOrValue<BytesLike>]): string;
     encodeFunctionData(functionFragment: "pubkey", values: [PromiseOrValue<BytesLike>]): string;
+    encodeFunctionData(functionFragment: "recordVersions", values: [PromiseOrValue<BytesLike>]): string;
     encodeFunctionData(functionFragment: "setABI", values: [
         PromiseOrValue<BytesLike>,
         PromiseOrValue<BigNumberish>,
@@ -85,15 +89,17 @@ export interface PublicResolverInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: "ABI", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "addr(bytes32)", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "addr(bytes32,uint256)", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "clearDNSZone", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "clearRecords", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "contenthash", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "dnsRecord", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "hasDNSRecords", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "interfaceImplementer", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "isApprovedForAll", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "multicallWithNodeCheck", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "pubkey", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "recordVersions", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "setABI", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "setAddr(bytes32,uint256,bytes)", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "setAddr(bytes32,address)", data: BytesLike): Result;
@@ -116,12 +122,12 @@ export interface PublicResolverInterface extends utils.Interface {
         "ContenthashChanged(bytes32,bytes)": EventFragment;
         "DNSRecordChanged(bytes32,bytes,uint16,bytes)": EventFragment;
         "DNSRecordDeleted(bytes32,bytes,uint16)": EventFragment;
-        "DNSZoneCleared(bytes32)": EventFragment;
         "DNSZonehashChanged(bytes32,bytes,bytes)": EventFragment;
         "InterfaceChanged(bytes32,bytes4,address)": EventFragment;
         "NameChanged(bytes32,string)": EventFragment;
         "PubkeyChanged(bytes32,bytes32,bytes32)": EventFragment;
-        "TextChanged(bytes32,string,string)": EventFragment;
+        "TextChanged(bytes32,string,string,string)": EventFragment;
+        "VersionChanged(bytes32,uint64)": EventFragment;
     };
     getEvent(nameOrSignatureOrTopic: "ABIChanged"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "AddrChanged"): EventFragment;
@@ -130,12 +136,12 @@ export interface PublicResolverInterface extends utils.Interface {
     getEvent(nameOrSignatureOrTopic: "ContenthashChanged"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "DNSRecordChanged"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "DNSRecordDeleted"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "DNSZoneCleared"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "DNSZonehashChanged"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "InterfaceChanged"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "NameChanged"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "PubkeyChanged"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "TextChanged"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "VersionChanged"): EventFragment;
 }
 export interface ABIChangedEventObject {
     node: string;
@@ -210,13 +216,6 @@ export declare type DNSRecordDeletedEvent = TypedEvent<[
     number
 ], DNSRecordDeletedEventObject>;
 export declare type DNSRecordDeletedEventFilter = TypedEventFilter<DNSRecordDeletedEvent>;
-export interface DNSZoneClearedEventObject {
-    node: string;
-}
-export declare type DNSZoneClearedEvent = TypedEvent<[
-    string
-], DNSZoneClearedEventObject>;
-export declare type DNSZoneClearedEventFilter = TypedEventFilter<DNSZoneClearedEvent>;
 export interface DNSZonehashChangedEventObject {
     node: string;
     lastzonehash: string;
@@ -263,13 +262,24 @@ export interface TextChangedEventObject {
     node: string;
     indexedKey: string;
     key: string;
+    value: string;
 }
 export declare type TextChangedEvent = TypedEvent<[
+    string,
     string,
     string,
     string
 ], TextChangedEventObject>;
 export declare type TextChangedEventFilter = TypedEventFilter<TextChangedEvent>;
+export interface VersionChangedEventObject {
+    node: string;
+    newVersion: BigNumber;
+}
+export declare type VersionChangedEvent = TypedEvent<[
+    string,
+    BigNumber
+], VersionChangedEventObject>;
+export declare type VersionChangedEventFilter = TypedEventFilter<VersionChangedEvent>;
 export interface PublicResolver extends BaseContract {
     connect(signerOrProvider: Signer | Provider | string): this;
     attach(addressOrName: string): this;
@@ -288,7 +298,7 @@ export interface PublicResolver extends BaseContract {
         ABI(node: PromiseOrValue<BytesLike>, contentTypes: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber, string]>;
         "addr(bytes32)"(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string]>;
         "addr(bytes32,uint256)"(node: PromiseOrValue<BytesLike>, coinType: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
-        clearDNSZone(node: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        clearRecords(node: PromiseOrValue<BytesLike>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
         contenthash(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string]>;
@@ -299,11 +309,15 @@ export interface PublicResolver extends BaseContract {
         multicall(data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
+        multicallWithNodeCheck(nodehash: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
         name(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string]>;
         pubkey(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string] & {
             x: string;
             y: string;
         }>;
+        recordVersions(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[BigNumber]>;
         setABI(node: PromiseOrValue<BytesLike>, contentType: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
@@ -344,7 +358,7 @@ export interface PublicResolver extends BaseContract {
     ABI(node: PromiseOrValue<BytesLike>, contentTypes: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber, string]>;
     "addr(bytes32)"(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
     "addr(bytes32,uint256)"(node: PromiseOrValue<BytesLike>, coinType: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
-    clearDNSZone(node: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+    clearRecords(node: PromiseOrValue<BytesLike>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
     contenthash(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
@@ -355,11 +369,15 @@ export interface PublicResolver extends BaseContract {
     multicall(data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
+    multicallWithNodeCheck(nodehash: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
     name(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
     pubkey(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string] & {
         x: string;
         y: string;
     }>;
+    recordVersions(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
     setABI(node: PromiseOrValue<BytesLike>, contentType: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
@@ -400,18 +418,20 @@ export interface PublicResolver extends BaseContract {
         ABI(node: PromiseOrValue<BytesLike>, contentTypes: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber, string]>;
         "addr(bytes32)"(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
         "addr(bytes32,uint256)"(node: PromiseOrValue<BytesLike>, coinType: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
-        clearDNSZone(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
+        clearRecords(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
         contenthash(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
         dnsRecord(node: PromiseOrValue<BytesLike>, name: PromiseOrValue<BytesLike>, resource: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
         hasDNSRecords(node: PromiseOrValue<BytesLike>, name: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
         interfaceImplementer(node: PromiseOrValue<BytesLike>, interfaceID: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
         isApprovedForAll(account: PromiseOrValue<string>, operator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
         multicall(data: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<string[]>;
+        multicallWithNodeCheck(nodehash: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<string[]>;
         name(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
         pubkey(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string, string] & {
             x: string;
             y: string;
         }>;
+        recordVersions(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
         setABI(node: PromiseOrValue<BytesLike>, contentType: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
         "setAddr(bytes32,uint256,bytes)"(node: PromiseOrValue<BytesLike>, coinType: PromiseOrValue<BigNumberish>, a: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
         "setAddr(bytes32,address)"(node: PromiseOrValue<BytesLike>, a: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
@@ -442,8 +462,6 @@ export interface PublicResolver extends BaseContract {
         DNSRecordChanged(node?: PromiseOrValue<BytesLike> | null, name?: null, resource?: null, record?: null): DNSRecordChangedEventFilter;
         "DNSRecordDeleted(bytes32,bytes,uint16)"(node?: PromiseOrValue<BytesLike> | null, name?: null, resource?: null): DNSRecordDeletedEventFilter;
         DNSRecordDeleted(node?: PromiseOrValue<BytesLike> | null, name?: null, resource?: null): DNSRecordDeletedEventFilter;
-        "DNSZoneCleared(bytes32)"(node?: PromiseOrValue<BytesLike> | null): DNSZoneClearedEventFilter;
-        DNSZoneCleared(node?: PromiseOrValue<BytesLike> | null): DNSZoneClearedEventFilter;
         "DNSZonehashChanged(bytes32,bytes,bytes)"(node?: PromiseOrValue<BytesLike> | null, lastzonehash?: null, zonehash?: null): DNSZonehashChangedEventFilter;
         DNSZonehashChanged(node?: PromiseOrValue<BytesLike> | null, lastzonehash?: null, zonehash?: null): DNSZonehashChangedEventFilter;
         "InterfaceChanged(bytes32,bytes4,address)"(node?: PromiseOrValue<BytesLike> | null, interfaceID?: PromiseOrValue<BytesLike> | null, implementer?: null): InterfaceChangedEventFilter;
@@ -452,14 +470,16 @@ export interface PublicResolver extends BaseContract {
         NameChanged(node?: PromiseOrValue<BytesLike> | null, name?: null): NameChangedEventFilter;
         "PubkeyChanged(bytes32,bytes32,bytes32)"(node?: PromiseOrValue<BytesLike> | null, x?: null, y?: null): PubkeyChangedEventFilter;
         PubkeyChanged(node?: PromiseOrValue<BytesLike> | null, x?: null, y?: null): PubkeyChangedEventFilter;
-        "TextChanged(bytes32,string,string)"(node?: PromiseOrValue<BytesLike> | null, indexedKey?: PromiseOrValue<string> | null, key?: null): TextChangedEventFilter;
-        TextChanged(node?: PromiseOrValue<BytesLike> | null, indexedKey?: PromiseOrValue<string> | null, key?: null): TextChangedEventFilter;
+        "TextChanged(bytes32,string,string,string)"(node?: PromiseOrValue<BytesLike> | null, indexedKey?: PromiseOrValue<string> | null, key?: null, value?: null): TextChangedEventFilter;
+        TextChanged(node?: PromiseOrValue<BytesLike> | null, indexedKey?: PromiseOrValue<string> | null, key?: null, value?: null): TextChangedEventFilter;
+        "VersionChanged(bytes32,uint64)"(node?: PromiseOrValue<BytesLike> | null, newVersion?: null): VersionChangedEventFilter;
+        VersionChanged(node?: PromiseOrValue<BytesLike> | null, newVersion?: null): VersionChangedEventFilter;
     };
     estimateGas: {
         ABI(node: PromiseOrValue<BytesLike>, contentTypes: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
         "addr(bytes32)"(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
         "addr(bytes32,uint256)"(node: PromiseOrValue<BytesLike>, coinType: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
-        clearDNSZone(node: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        clearRecords(node: PromiseOrValue<BytesLike>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
         contenthash(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
@@ -470,8 +490,12 @@ export interface PublicResolver extends BaseContract {
         multicall(data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
+        multicallWithNodeCheck(nodehash: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
         name(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
         pubkey(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
+        recordVersions(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
         setABI(node: PromiseOrValue<BytesLike>, contentType: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
@@ -513,7 +537,7 @@ export interface PublicResolver extends BaseContract {
         ABI(node: PromiseOrValue<BytesLike>, contentTypes: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         "addr(bytes32)"(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         "addr(bytes32,uint256)"(node: PromiseOrValue<BytesLike>, coinType: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        clearDNSZone(node: PromiseOrValue<BytesLike>, overrides?: Overrides & {
+        clearRecords(node: PromiseOrValue<BytesLike>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
         contenthash(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
@@ -524,8 +548,12 @@ export interface PublicResolver extends BaseContract {
         multicall(data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
+        multicallWithNodeCheck(nodehash: PromiseOrValue<BytesLike>, data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
         name(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         pubkey(node: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        recordVersions(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         setABI(node: PromiseOrValue<BytesLike>, contentType: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;

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

@@ -59,10 +59,12 @@ export interface ReverseRegistrarInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
     events: {
         "ControllerChanged(address,bool)": EventFragment;
+        "DefaultResolverChanged(address)": EventFragment;
         "OwnershipTransferred(address,address)": EventFragment;
         "ReverseClaimed(address,bytes32)": EventFragment;
     };
     getEvent(nameOrSignatureOrTopic: "ControllerChanged"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "DefaultResolverChanged"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "ReverseClaimed"): EventFragment;
 }
@@ -75,6 +77,13 @@ export declare type ControllerChangedEvent = TypedEvent<[
     boolean
 ], ControllerChangedEventObject>;
 export declare type ControllerChangedEventFilter = TypedEventFilter<ControllerChangedEvent>;
+export interface DefaultResolverChangedEventObject {
+    resolver: string;
+}
+export declare type DefaultResolverChangedEvent = TypedEvent<[
+    string
+], DefaultResolverChangedEventObject>;
+export declare type DefaultResolverChangedEventFilter = TypedEventFilter<DefaultResolverChangedEvent>;
 export interface OwnershipTransferredEventObject {
     previousOwner: string;
     newOwner: string;
@@ -192,6 +201,8 @@ export interface ReverseRegistrar extends BaseContract {
     filters: {
         "ControllerChanged(address,bool)"(controller?: PromiseOrValue<string> | null, enabled?: null): ControllerChangedEventFilter;
         ControllerChanged(controller?: PromiseOrValue<string> | null, enabled?: null): ControllerChangedEventFilter;
+        "DefaultResolverChanged(address)"(resolver?: PromiseOrValue<string> | null): DefaultResolverChangedEventFilter;
+        DefaultResolverChanged(resolver?: PromiseOrValue<string> | null): DefaultResolverChangedEventFilter;
         "OwnershipTransferred(address,address)"(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
         OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
         "ReverseClaimed(address,bytes32)"(addr?: PromiseOrValue<string> | null, node?: PromiseOrValue<BytesLike> | null): ReverseClaimedEventFilter;

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

@@ -10,8 +10,19 @@ export declare class ETHRegistrarController__factory {
         }[];
         stateMutability: string;
         type: string;
-        anonymous?: undefined;
         name?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        anonymous?: undefined;
         outputs?: undefined;
     } | {
         anonymous: boolean;

package/dist/types/index.d.ts

@@ -8,12 +8,13 @@ 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 renewNames from './functions/renewNames';
+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 transferName from './functions/transferName';
+import type transferController from './functions/transferController';
 import type transferSubname from './functions/transferSubname';
 import type unwrapName from './functions/unwrapName';
 import type wrapName from './functions/wrapName';
@@ -225,7 +226,7 @@ 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;
@@ -443,6 +444,7 @@ export declare class ENS {
     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>;
@@ -452,4 +454,5 @@ export declare class ENS {
     commitName: WriteFunction<typeof commitName>;
     registerName: WriteFunction<typeof registerName>;
     renewNames: WriteFunction<typeof renewNames>;
+    renewNameWithData: WriteFunction<typeof renewNameWithData>;
 }

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

@@ -21,6 +21,8 @@ declare const fullFuseEnum: {
 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;
@@ -40,4 +42,15 @@ declare type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibili
 ] : 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 default fullFuseEnum;

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

@@ -4,6 +4,7 @@ declare type RecordItem = {
     value: string;
 };
 export declare type RecordOptions = {
+    clearRecords?: boolean;
     contentHash?: string;
     texts?: RecordItem[];
     coinTypes?: RecordItem[];

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

@@ -1,20 +1,25 @@
+import { BigNumberish } from 'ethers';
 import type { FuseOptions } from '../@types/FuseOptions';
 import type { PublicResolver } from '../generated';
 import { RecordOptions } from './recordHelpers';
-export declare type RegistrationParams = {
-    name: string;
+export declare const MAX_INT_64: bigint;
+export declare type BaseRegistrationParams = {
     owner: string;
     duration: number;
     secret: string;
-    resolver: PublicResolver;
+    resolverAddress?: string;
     records?: RecordOptions;
     reverseRecord?: boolean;
     fuses?: FuseOptions;
-    wrapperExpiry: number;
+    wrapperExpiry?: BigNumberish;
+};
+export declare type RegistrationParams = Omit<BaseRegistrationParams, 'resolverAddress'> & {
+    name: string;
+    resolver: PublicResolver;
 };
 export declare type CommitmentParams = Omit<RegistrationParams, 'secret' | 'wrapperExpiry'> & {
     secret?: string;
-    wrapperExpiry?: number;
+    wrapperExpiry?: BigNumberish;
 };
 export declare type RegistrationTuple = [
     name: string,
@@ -25,7 +30,7 @@ export declare type RegistrationTuple = [
     data: string[],
     reverseRecord: boolean,
     fuses: string,
-    wrapperExpiry: number
+    wrapperExpiry: BigNumberish
 ];
 export declare type CommitmentTuple = [
     labelhash: string,
@@ -36,12 +41,12 @@ export declare type CommitmentTuple = [
     secret: string,
     reverseRecord: boolean,
     fuses: string,
-    wrapperExpiry: number
+    wrapperExpiry: BigNumberish
 ];
 export declare const randomSecret: () => string;
 export declare const makeCommitmentData: ({ name, owner, duration, resolver, records, reverseRecord, fuses, wrapperExpiry, secret, }: Omit<RegistrationParams, "secret" | "wrapperExpiry"> & {
     secret?: string | undefined;
-    wrapperExpiry?: number | undefined;
+    wrapperExpiry?: BigNumberish | undefined;
 } & {
     secret: string;
 }) => CommitmentTuple;
@@ -50,5 +55,5 @@ export declare const _makeCommitment: (params: CommitmentTuple) => string;
 export declare const makeCommitment: ({ secret, ...inputParams }: CommitmentParams) => {
     secret: string;
     commitment: string;
-    wrapperExpiry: number;
+    wrapperExpiry: BigNumberish;
 };

package/dist/types/utils/{wrapperExpiry.d.ts → wrapper.d.ts}

@@ -1,5 +1,6 @@
 import { BigNumber } from 'ethers';
-import { ENSArgs } from '..';
+import { ENSArgs } from '../index';
 export declare type Expiry = string | number | Date | BigNumber;
 export declare const MAX_EXPIRY: BigNumber;
 export declare const makeExpiry: ({ getExpiry }: ENSArgs<'getExpiry'>, name: string, expiry?: Expiry) => Promise<BigNumber>;
+export declare const wrappedLabelLengthCheck: (label: string) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.21",
+  "version": "3.0.0-alpha.23",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -63,12 +63,13 @@
   },
   "devDependencies": {
     "@ensdomains/buffer": "^0.0.13",
-    "@ensdomains/ens-contracts": "^0.0.12",
-    "@ensdomains/ens-test-env": "0.2.3",
+    "@ensdomains/ens-contracts": "^0.0.14",
+    "@ensdomains/ens-test-env": "0.3.0",
     "@ethersproject/abi": "^5.6.0",
     "@ethersproject/providers": "^5.6.2",
     "@nomiclabs/hardhat-ethers": "npm:hardhat-deploy-ethers",
     "@openzeppelin/contracts": "^4.5.0",
+    "@openzeppelin/test-helpers": "^0.5.16",
     "@swc/core": "^1.2.162",
     "@swc/jest": "^0.2.20",
     "@typechain/ethers-v5": "^10.1.0",
@@ -101,7 +102,7 @@
   },
   "scripts": {
     "tenv": "ens-test-env -a",
-    "denv": "pnpm tenv start -ns -nb",
+    "denv": "pnpm tenv start -ns -nb --extra-time 11368000",
     "generate-types": "ts-node scripts/runTypechain.ts",
     "generate-abis": "hardhat export-abi",
     "start": "ts-node --files src/index.test.ts",

package/src/functions/burnFuses.test.ts

@@ -35,7 +35,7 @@ describe('burnFuses', () => {
       await tx.wait()
 
       const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
-      const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
       expect(fuses).toBe(113)
     })
     it('should return a burnFuses transaction from an unnamed fuse array and succeed', async () => {
@@ -54,7 +54,7 @@ describe('burnFuses', () => {
       await tx.wait()
 
       const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
-      const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
       expect(fuses).toBe(961)
     })
     it('should return a burnFuses transaction from both an unnamed and named fuse array and succeed', async () => {
@@ -71,7 +71,7 @@ describe('burnFuses', () => {
       await tx.wait()
 
       const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
-      const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
       expect(fuses).toBe(1009)
     })
     it('should throw an error when trying to burn a named fuse in an unnamed fuse array', async () => {
@@ -107,7 +107,7 @@ describe('burnFuses', () => {
       await tx.wait()
 
       const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
-      const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
+      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
       expect(fuses).toBe(113)
     })
     it('should throw an error if the number is too high', async () => {

package/src/functions/burnFuses.ts

@@ -1,76 +1,13 @@
 import { ENSArgs } from '..'
-import {
-  fuseEnum,
-  NamedFusesToBurn,
-  unnamedFuses,
-  UnnamedFuseValues,
-} from '../utils/fuses'
+import { FuseProps, validateFuses } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
 
-export type FusePropsNamedArray = {
-  namedFusesToBurn: NamedFusesToBurn
-}
-
-export type FusePropsUnnamedArray = {
-  unnamedFusesToBurn: UnnamedFuseValues[]
-}
-
-export type FusePropsNumber = {
-  fuseNumberToBurn: number
-}
-
-export type FuseProps =
-  | (Partial<FusePropsNamedArray> & FusePropsUnnamedArray)
-  | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>)
-  | FusePropsNumber
-
 export default async function (
   { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
   props: FuseProps,
 ) {
-  const isNumber = 'fuseNumberToBurn' in props
-  const hasNamedArray = 'namedFusesToBurn' in props
-  const hasUnnamedArray = 'unnamedFusesToBurn' in props
-
-  let encodedFuses: number = 0
-
-  if (isNumber) {
-    if (props.fuseNumberToBurn > 2 ** 32 || props.fuseNumberToBurn < 1) {
-      throw new Error(
-        `Fuse number must be limited to uint32, ${
-          props.fuseNumberToBurn
-        } was too ${props.fuseNumberToBurn < 1 ? 'low' : 'high'}.`,
-      )
-    } else if (props.fuseNumberToBurn % 1 !== 0) {
-      throw new Error(
-        `Fuse number must be an integer, ${props.fuseNumberToBurn} was not.`,
-      )
-    }
-    encodedFuses = props.fuseNumberToBurn
-  } else {
-    if (!hasNamedArray && !hasUnnamedArray) {
-      throw new Error('Please provide fuses to burn')
-    }
-    if (hasNamedArray) {
-      for (const fuse of props.namedFusesToBurn!) {
-        if (!(fuse in fuseEnum)) {
-          throw new Error(`${fuse} is not a valid named fuse.`)
-        }
-        encodedFuses |= fuseEnum[fuse]
-      }
-    }
-    if (hasUnnamedArray) {
-      for (const fuse of props.unnamedFusesToBurn!) {
-        if (!unnamedFuses.includes(fuse)) {
-          throw new Error(
-            `${fuse} is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.`,
-          )
-        }
-        encodedFuses |= fuse
-      }
-    }
-  }
+  const encodedFuses = validateFuses(props)
 
   const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
   const hash = namehash(name)

package/src/functions/commitName.ts

@@ -1,5 +1,6 @@
 import { ENSArgs } from '..'
 import { CommitmentParams, makeCommitment } from '../utils/registerHelpers'
+import { wrappedLabelLengthCheck } from '../utils/wrapper'
 
 type Params = Omit<CommitmentParams, 'resolver' | 'name'> & {
   resolverAddress?: string
@@ -14,6 +15,8 @@ export default async function (
   if (labels.length !== 2 || labels[1] !== 'eth')
     throw new Error('Currently only .eth TLD registrations are supported')
 
+  wrappedLabelLengthCheck(labels[0])
+
   const controller = await contracts!.getEthRegistrarController()
   const resolver = await contracts!.getPublicResolver(
     undefined,