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

package/dist/types/functions/getWrapperData.d.ts

@@ -1,4 +1,3 @@
-import { BigNumber } from '@ethersproject/bignumber/lib/bignumber';
 import { ENSArgs } from '../index';
 declare const _default: {
     raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
@@ -6,10 +5,50 @@ declare const _default: {
         data: string;
     }>;
     decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
-        fuseObj: import("../utils/fuses").CurrentFuses;
-        expiryDate: Date;
-        rawFuses: 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>;
 };
 export default _default;

package/dist/types/functions/importDNSSECName.d.ts

@@ -4,4 +4,4 @@ export declare type ImportDNSSECNameProps = {
     address: string;
     proverResult: any;
 };
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'signer' | 'provider'>, name: string, { address, proverResult }: ImportDNSSECNameProps): Promise<import("@ethersproject/contracts").PopulatedTransaction | undefined>;
+export default function ({ contracts, provider }: ENSArgs<'contracts' | 'signer' | 'provider'>, name: string, { address, proverResult }: ImportDNSSECNameProps): Promise<import("ethers").PopulatedTransaction | undefined>;

package/dist/types/functions/registerName.d.ts

@@ -4,5 +4,5 @@ import { BaseRegistrationParams } from '../utils/registerHelpers';
 declare type Params = BaseRegistrationParams & {
     value: BigNumber;
 };
-export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { resolverAddress, value, ...params }: Params): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { resolverAddress, value, ...params }: Params): Promise<import("ethers").PopulatedTransaction>;
 export {};

package/dist/types/functions/renewNames.d.ts

@@ -1,13 +1,12 @@
 import { BigNumber, BigNumberish } from '@ethersproject/bignumber/lib/bignumber';
 import { ENSArgs } from '..';
-import { FuseProps } from '../utils/fuses';
 declare type BaseProps = {
     duration: number;
     value: BigNumber;
 };
-export declare function renewNameWithData({ contracts }: ENSArgs<'contracts'>, name: string, { duration, value, fuses, wrapperExpiry, }: BaseProps & {
-    fuses?: FuseProps;
-    wrapperExpiry?: BigNumberish;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
-export default function ({ contracts }: ENSArgs<'contracts'>, nameOrNames: string | string[], { duration, value }: BaseProps): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+declare type WrappedProps = {
+    duration: BigNumberish;
+};
+export declare function extendWrappedName({ contracts }: ENSArgs<'contracts'>, name: string, options?: WrappedProps): Promise<import("ethers").PopulatedTransaction>;
+export default function ({ contracts }: ENSArgs<'contracts'>, nameOrNames: string | string[], { duration, value }: BaseProps): Promise<import("ethers").PopulatedTransaction>;
 export {};

package/dist/types/functions/setFuses.d.ts

@@ -0,0 +1,7 @@
+import { ENSArgs } from '../index';
+import { CombinedFuseInput } from '../utils/fuses';
+export declare function setChildFuses({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { fuses, expiry, }: {
+    fuses: Partial<CombinedFuseInput> | number;
+    expiry?: number;
+}): Promise<import("ethers").PopulatedTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: CombinedFuseInput['child']): Promise<import("ethers").PopulatedTransaction>;

package/dist/types/functions/setName.d.ts

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { address, resolver, }?: {
     address?: string;
     resolver?: string;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/types/functions/setRecord.d.ts

@@ -11,7 +11,11 @@ declare type AddrOrTextInput = {
     record: RecordInput<'addr' | 'text'>;
     type: 'addr' | 'text';
 };
-export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput)): Promise<{
+declare type ABIInput = {
+    record: RecordInput<'abi'>;
+    type: 'abi';
+};
+export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput | ABIInput)): Promise<{
     to: string;
     data: string;
 }>;

package/dist/types/functions/setRecords.d.ts

@@ -3,4 +3,4 @@ import { RecordOptions } from '../utils/recordHelpers';
 export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { records, resolverAddress, }: {
     records: RecordOptions;
     resolverAddress?: string;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/types/functions/setResolver.d.ts

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { contract, resolver, }: {
     contract: 'registry' | 'nameWrapper';
     resolver?: string;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/types/functions/transferController.d.ts

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newOwner, isOwner, }: {
     newOwner: string;
     isOwner: boolean;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/types/functions/transferName.d.ts

@@ -3,4 +3,4 @@ export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>,
     newOwner: string;
     contract: 'registry' | 'nameWrapper' | 'baseRegistrar';
     reclaim?: boolean;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/types/functions/transferSubname.d.ts

@@ -10,5 +10,5 @@ declare type NameWrapperArgs = {
     expiry?: Expiry;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract, owner, resolverAddress, ...wrapperArgs }: Args): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { contract, owner, resolverAddress, ...wrapperArgs }: Args): Promise<import("ethers").PopulatedTransaction>;
 export {};

package/dist/types/functions/types.d.ts

@@ -1,6 +1,5 @@
 import type batch from './batch';
 import type { multicallWrapper, resolverMulticallWrapper, universalWrapper } from './batchWrappers';
-import type burnFuses from './burnFuses';
 import type commitName from './commitName';
 import type createSubname from './createSubname';
 import type deleteSubname from './deleteSubname';
@@ -15,12 +14,14 @@ import type getPrice from './getPrice';
 import type getProfile from './getProfile';
 import type getRecords from './getRecords';
 import type getResolver from './getResolver';
-import type { getAddr, getContentHash, getText, _getAddr, _getContentHash, _getText } from './getSpecificRecord';
+import type { getABI, getAddr, getContentHash, getText, _getABI, _getAddr, _getContentHash, _getText } from './getSpecificRecord';
 import type getSubnames from './getSubnames';
 import type getWrapperData from './getWrapperData';
 import type importDNSSECName from './importDNSSECName';
 import type registerName from './registerName';
-import type { default as renewNames, renewNameWithData } from './renewNames';
+import type { default as renewNames, extendWrappedName } from './renewNames';
+import type setFuses from './setFuses';
+import type { setChildFuses } from './setFuses';
 import type setName from './setName';
 import type setRecord from './setRecord';
 import type setRecords from './setRecords';
@@ -36,7 +37,8 @@ declare type Function = {
     multicallWrapper: typeof multicallWrapper;
     resolverMulticallWrapper: typeof resolverMulticallWrapper;
     universalWrapper: typeof universalWrapper;
-    burnFuses: typeof burnFuses;
+    setFuses: typeof setFuses;
+    setChildFuses: typeof setChildFuses;
     commitName: typeof commitName;
     createSubname: typeof createSubname;
     deleteSubname: typeof deleteSubname;
@@ -54,15 +56,17 @@ declare type Function = {
     getAddr: typeof getAddr;
     getContentHash: typeof getContentHash;
     getText: typeof getText;
+    getABI: typeof getABI;
     _getAddr: typeof _getAddr;
     _getContentHash: typeof _getContentHash;
     _getText: typeof _getText;
+    _getABI: typeof _getABI;
     getSubnames: typeof getSubnames;
     getWrapperData: typeof getWrapperData;
     importDNSSECName: typeof importDNSSECName;
     registerName: typeof registerName;
     renewNames: typeof renewNames;
-    renewNameWithData: typeof renewNameWithData;
+    extendWrappedName: typeof extendWrappedName;
     setName: typeof setName;
     setRecord: typeof setRecord;
     setRecords: typeof setRecords;

package/dist/types/functions/unwrapName.d.ts

@@ -2,4 +2,4 @@ import { ENSArgs } from '..';
 export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { newController, newRegistrant, }: {
     newController: string;
     newRegistrant?: string;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/types/functions/wrapName.d.ts

@@ -1,9 +1,9 @@
 import { ENSArgs } from '..';
-import { FuseOptions } from '../utils/fuses';
+import { CombinedFuseInput } from '../utils/fuses';
 import { Expiry } from '../utils/wrapper';
-export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { wrappedOwner, fuseOptions, expiry, resolverAddress, }: {
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { wrappedOwner, fuseOptions, expiry, resolverAddress, }: {
     wrappedOwner: string;
-    fuseOptions?: FuseOptions | string | number;
+    fuseOptions?: Partial<CombinedFuseInput> | number;
     expiry?: Expiry;
     resolverAddress?: string;
-}): Promise<import("@ethersproject/contracts").PopulatedTransaction>;
+}): Promise<import("ethers").PopulatedTransaction>;

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

@@ -22,16 +22,15 @@ export interface ETHRegistrarControllerInterface extends Interface {
         'available(string)': FunctionFragment;
         'commit(bytes32)': FunctionFragment;
         'commitments(bytes32)': FunctionFragment;
-        'makeCommitment(string,address,uint256,bytes32,address,bytes[],bool,uint32,uint64)': FunctionFragment;
+        'makeCommitment(string,address,uint256,bytes32,address,bytes[],bool,uint16)': FunctionFragment;
         'maxCommitmentAge()': FunctionFragment;
         'minCommitmentAge()': FunctionFragment;
         'nameWrapper()': FunctionFragment;
         'owner()': FunctionFragment;
         'prices()': FunctionFragment;
         'recoverFunds(address,address,uint256)': FunctionFragment;
-        'register(string,address,uint256,bytes32,address,bytes[],bool,uint32,uint64)': FunctionFragment;
+        'register(string,address,uint256,bytes32,address,bytes[],bool,uint16)': FunctionFragment;
         'renew(string,uint256)': FunctionFragment;
-        'renewWithFuses(string,uint256,uint32,uint64)': FunctionFragment;
         'renounceOwnership()': FunctionFragment;
         'rentPrice(string,uint256)': FunctionFragment;
         'reverseRegistrar()': FunctionFragment;
@@ -40,7 +39,7 @@ export interface ETHRegistrarControllerInterface extends Interface {
         'valid(string)': FunctionFragment;
         'withdraw()': FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: 'MIN_REGISTRATION_DURATION' | 'available' | 'commit' | 'commitments' | 'makeCommitment' | 'maxCommitmentAge' | 'minCommitmentAge' | 'nameWrapper' | 'owner' | 'prices' | 'recoverFunds' | 'register' | 'renew' | 'renewWithFuses' | 'renounceOwnership' | 'rentPrice' | 'reverseRegistrar' | 'supportsInterface' | 'transferOwnership' | 'valid' | 'withdraw'): FunctionFragment;
+    getFunction(nameOrSignatureOrTopic: 'MIN_REGISTRATION_DURATION' | 'available' | 'commit' | 'commitments' | 'makeCommitment' | 'maxCommitmentAge' | 'minCommitmentAge' | 'nameWrapper' | 'owner' | 'prices' | 'recoverFunds' | 'register' | 'renew' | 'renounceOwnership' | 'rentPrice' | 'reverseRegistrar' | 'supportsInterface' | 'transferOwnership' | 'valid' | 'withdraw'): FunctionFragment;
     encodeFunctionData(functionFragment: 'MIN_REGISTRATION_DURATION', values?: undefined): string;
     encodeFunctionData(functionFragment: 'available', values: [PromiseOrValue<string>]): string;
     encodeFunctionData(functionFragment: 'commit', values: [PromiseOrValue<BytesLike>]): string;
@@ -53,7 +52,6 @@ export interface ETHRegistrarControllerInterface extends Interface {
         PromiseOrValue<string>,
         PromiseOrValue<BytesLike>[],
         PromiseOrValue<boolean>,
-        PromiseOrValue<BigNumberish>,
         PromiseOrValue<BigNumberish>
     ]): string;
     encodeFunctionData(functionFragment: 'maxCommitmentAge', values?: undefined): string;
@@ -74,16 +72,9 @@ export interface ETHRegistrarControllerInterface extends Interface {
         PromiseOrValue<string>,
         PromiseOrValue<BytesLike>[],
         PromiseOrValue<boolean>,
-        PromiseOrValue<BigNumberish>,
         PromiseOrValue<BigNumberish>
     ]): string;
     encodeFunctionData(functionFragment: 'renew', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
-    encodeFunctionData(functionFragment: 'renewWithFuses', values: [
-        PromiseOrValue<string>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>,
-        PromiseOrValue<BigNumberish>
-    ]): string;
     encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string;
     encodeFunctionData(functionFragment: 'rentPrice', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
     encodeFunctionData(functionFragment: 'reverseRegistrar', values?: undefined): string;
@@ -104,7 +95,6 @@ export interface ETHRegistrarControllerInterface extends Interface {
     decodeFunctionResult(functionFragment: 'recoverFunds', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'register', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'renew', data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: 'renewWithFuses', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'rentPrice', data: BytesLike): Result;
     decodeFunctionResult(functionFragment: 'reverseRegistrar', data: BytesLike): Result;
@@ -181,7 +171,7 @@ export interface ETHRegistrarController extends BaseContract {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
         commitments(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[BigNumber]>;
-        makeCommitment(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
+        makeCommitment(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, ownerControlledFuses: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
         maxCommitmentAge(overrides?: CallOverrides): Promise<[BigNumber]>;
         minCommitmentAge(overrides?: CallOverrides): Promise<[BigNumber]>;
         nameWrapper(overrides?: CallOverrides): Promise<[string]>;
@@ -190,15 +180,12 @@ export interface ETHRegistrarController extends BaseContract {
         recoverFunds(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
-        register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
+        register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, ownerControlledFuses: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
         renew(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
-        renewWithFuses(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
-            from?: PromiseOrValue<string>;
-        }): Promise<ContractTransaction>;
         renounceOwnership(overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<ContractTransaction>;
@@ -223,7 +210,7 @@ export interface ETHRegistrarController extends BaseContract {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
     commitments(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
-    makeCommitment(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+    makeCommitment(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, ownerControlledFuses: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
     maxCommitmentAge(overrides?: CallOverrides): Promise<BigNumber>;
     minCommitmentAge(overrides?: CallOverrides): Promise<BigNumber>;
     nameWrapper(overrides?: CallOverrides): Promise<string>;
@@ -232,15 +219,12 @@ export interface ETHRegistrarController extends BaseContract {
     recoverFunds(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
-    register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
+    register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, ownerControlledFuses: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
     renew(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
-    renewWithFuses(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
-        from?: PromiseOrValue<string>;
-    }): Promise<ContractTransaction>;
     renounceOwnership(overrides?: Overrides & {
         from?: PromiseOrValue<string>;
     }): Promise<ContractTransaction>;
@@ -259,16 +243,15 @@ export interface ETHRegistrarController extends BaseContract {
         available(name: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
         commit(commitment: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
         commitments(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
-        makeCommitment(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
+        makeCommitment(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, ownerControlledFuses: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
         maxCommitmentAge(overrides?: CallOverrides): Promise<BigNumber>;
         minCommitmentAge(overrides?: CallOverrides): Promise<BigNumber>;
         nameWrapper(overrides?: CallOverrides): Promise<string>;
         owner(overrides?: CallOverrides): Promise<string>;
         prices(overrides?: CallOverrides): Promise<string>;
         recoverFunds(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
-        register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
+        register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, ownerControlledFuses: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
         renew(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
-        renewWithFuses(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
         renounceOwnership(overrides?: CallOverrides): Promise<void>;
         rentPrice(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<IPriceOracle.PriceStructOutput>;
         reverseRegistrar(overrides?: CallOverrides): Promise<string>;
@@ -292,7 +275,7 @@ export interface ETHRegistrarController extends BaseContract {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
         commitments(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
-        makeCommitment(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
+        makeCommitment(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, ownerControlledFuses: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
         maxCommitmentAge(overrides?: CallOverrides): Promise<BigNumber>;
         minCommitmentAge(overrides?: CallOverrides): Promise<BigNumber>;
         nameWrapper(overrides?: CallOverrides): Promise<BigNumber>;
@@ -301,15 +284,12 @@ export interface ETHRegistrarController extends BaseContract {
         recoverFunds(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
-        register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
+        register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, ownerControlledFuses: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
         renew(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
-        renewWithFuses(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
-            from?: PromiseOrValue<string>;
-        }): Promise<BigNumber>;
         renounceOwnership(overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<BigNumber>;
@@ -331,7 +311,7 @@ export interface ETHRegistrarController extends BaseContract {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
         commitments(arg0: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        makeCommitment(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        makeCommitment(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, ownerControlledFuses: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
         maxCommitmentAge(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         minCommitmentAge(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         nameWrapper(overrides?: CallOverrides): Promise<PopulatedTransaction>;
@@ -340,15 +320,12 @@ export interface ETHRegistrarController extends BaseContract {
         recoverFunds(_token: PromiseOrValue<string>, _to: PromiseOrValue<string>, _amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
-        register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
+        register(name: PromiseOrValue<string>, owner: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, secret: PromiseOrValue<BytesLike>, resolver: PromiseOrValue<string>, data: PromiseOrValue<BytesLike>[], reverseRecord: PromiseOrValue<boolean>, ownerControlledFuses: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
         renew(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;
-        renewWithFuses(name: PromiseOrValue<string>, duration: PromiseOrValue<BigNumberish>, fuses: PromiseOrValue<BigNumberish>, wrapperExpiry: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
-            from?: PromiseOrValue<string>;
-        }): Promise<PopulatedTransaction>;
         renounceOwnership(overrides?: Overrides & {
             from?: PromiseOrValue<string>;
         }): Promise<PopulatedTransaction>;