@ensdomains/ensjs 3.0.0-alpha.10 → 3.0.0-alpha.13

package/dist/cjs/generated/index.js

@@ -23,16 +23,44 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniversalResolver__factory = exports.StaticMetadataService__factory = exports.ReverseRegistrar__factory = exports.PublicResolver__factory = exports.NameWrapper__factory = exports.ETHRegistrarController__factory = exports.factories = void 0;
+exports.UniversalResolver__factory = exports.StaticMetadataService__factory = exports.NameWrapper__factory = exports.Multicall__factory = exports.TLDPublicSuffixList__factory = exports.SHA256Digest__factory = exports.SHA1NSEC3Digest__factory = exports.SHA1Digest__factory = exports.RSASHA256Algorithm__factory = exports.RSASHA1Algorithm__factory = exports.Root__factory = exports.ReverseRegistrar__factory = exports.PublicResolver__factory = exports.P256SHA256Algorithm__factory = exports.ETHRegistrarController__factory = exports.ENSRegistry__factory = exports.DNSSECImpl__factory = exports.DNSRegistrar__factory = exports.DefaultReverseResolver__factory = exports.BaseRegistrarImplementation__factory = exports.factories = void 0;
 exports.factories = __importStar(require("./factories"));
+var BaseRegistrarImplementation__factory_1 = require("./factories/BaseRegistrarImplementation__factory");
+Object.defineProperty(exports, "BaseRegistrarImplementation__factory", { enumerable: true, get: function () { return BaseRegistrarImplementation__factory_1.BaseRegistrarImplementation__factory; } });
+var DefaultReverseResolver__factory_1 = require("./factories/DefaultReverseResolver__factory");
+Object.defineProperty(exports, "DefaultReverseResolver__factory", { enumerable: true, get: function () { return DefaultReverseResolver__factory_1.DefaultReverseResolver__factory; } });
+var DNSRegistrar__factory_1 = require("./factories/DNSRegistrar__factory");
+Object.defineProperty(exports, "DNSRegistrar__factory", { enumerable: true, get: function () { return DNSRegistrar__factory_1.DNSRegistrar__factory; } });
+var DNSSECImpl__factory_1 = require("./factories/DNSSECImpl__factory");
+Object.defineProperty(exports, "DNSSECImpl__factory", { enumerable: true, get: function () { return DNSSECImpl__factory_1.DNSSECImpl__factory; } });
+var ENSRegistry__factory_1 = require("./factories/ENSRegistry__factory");
+Object.defineProperty(exports, "ENSRegistry__factory", { enumerable: true, get: function () { return ENSRegistry__factory_1.ENSRegistry__factory; } });
 var ETHRegistrarController__factory_1 = require("./factories/ETHRegistrarController__factory");
 Object.defineProperty(exports, "ETHRegistrarController__factory", { enumerable: true, get: function () { return ETHRegistrarController__factory_1.ETHRegistrarController__factory; } });
-var NameWrapper__factory_1 = require("./factories/NameWrapper__factory");
-Object.defineProperty(exports, "NameWrapper__factory", { enumerable: true, get: function () { return NameWrapper__factory_1.NameWrapper__factory; } });
+var P256SHA256Algorithm__factory_1 = require("./factories/P256SHA256Algorithm__factory");
+Object.defineProperty(exports, "P256SHA256Algorithm__factory", { enumerable: true, get: function () { return P256SHA256Algorithm__factory_1.P256SHA256Algorithm__factory; } });
 var PublicResolver__factory_1 = require("./factories/PublicResolver__factory");
 Object.defineProperty(exports, "PublicResolver__factory", { enumerable: true, get: function () { return PublicResolver__factory_1.PublicResolver__factory; } });
 var ReverseRegistrar__factory_1 = require("./factories/ReverseRegistrar__factory");
 Object.defineProperty(exports, "ReverseRegistrar__factory", { enumerable: true, get: function () { return ReverseRegistrar__factory_1.ReverseRegistrar__factory; } });
+var Root__factory_1 = require("./factories/Root__factory");
+Object.defineProperty(exports, "Root__factory", { enumerable: true, get: function () { return Root__factory_1.Root__factory; } });
+var RSASHA1Algorithm__factory_1 = require("./factories/RSASHA1Algorithm__factory");
+Object.defineProperty(exports, "RSASHA1Algorithm__factory", { enumerable: true, get: function () { return RSASHA1Algorithm__factory_1.RSASHA1Algorithm__factory; } });
+var RSASHA256Algorithm__factory_1 = require("./factories/RSASHA256Algorithm__factory");
+Object.defineProperty(exports, "RSASHA256Algorithm__factory", { enumerable: true, get: function () { return RSASHA256Algorithm__factory_1.RSASHA256Algorithm__factory; } });
+var SHA1Digest__factory_1 = require("./factories/SHA1Digest__factory");
+Object.defineProperty(exports, "SHA1Digest__factory", { enumerable: true, get: function () { return SHA1Digest__factory_1.SHA1Digest__factory; } });
+var SHA1NSEC3Digest__factory_1 = require("./factories/SHA1NSEC3Digest__factory");
+Object.defineProperty(exports, "SHA1NSEC3Digest__factory", { enumerable: true, get: function () { return SHA1NSEC3Digest__factory_1.SHA1NSEC3Digest__factory; } });
+var SHA256Digest__factory_1 = require("./factories/SHA256Digest__factory");
+Object.defineProperty(exports, "SHA256Digest__factory", { enumerable: true, get: function () { return SHA256Digest__factory_1.SHA256Digest__factory; } });
+var TLDPublicSuffixList__factory_1 = require("./factories/TLDPublicSuffixList__factory");
+Object.defineProperty(exports, "TLDPublicSuffixList__factory", { enumerable: true, get: function () { return TLDPublicSuffixList__factory_1.TLDPublicSuffixList__factory; } });
+var Multicall__factory_1 = require("./factories/Multicall__factory");
+Object.defineProperty(exports, "Multicall__factory", { enumerable: true, get: function () { return Multicall__factory_1.Multicall__factory; } });
+var NameWrapper__factory_1 = require("./factories/NameWrapper__factory");
+Object.defineProperty(exports, "NameWrapper__factory", { enumerable: true, get: function () { return NameWrapper__factory_1.NameWrapper__factory; } });
 var StaticMetadataService__factory_1 = require("./factories/StaticMetadataService__factory");
 Object.defineProperty(exports, "StaticMetadataService__factory", { enumerable: true, get: function () { return StaticMetadataService__factory_1.StaticMetadataService__factory; } });
 var UniversalResolver__factory_1 = require("./factories/UniversalResolver__factory");

package/dist/cjs/index.d.ts

@@ -4,8 +4,11 @@ import ContractManager from './contracts';
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
 import { SupportedNetworkId } from './contracts/types';
 import type burnFuses from './functions/burnFuses';
+import type commitName from './functions/commitName';
 import type createSubname from './functions/createSubname';
 import type deleteSubname from './functions/deleteSubname';
+import registerName from './functions/registerName';
+import renewName from './functions/renewName';
 import type setName from './functions/setName';
 import type setRecord from './functions/setRecord';
 import type setRecords from './functions/setRecords';
@@ -36,7 +39,9 @@ declare type WriteOptions = {
 };
 declare type OptionalWriteOptions<F> = F extends (x: any, arg_0: infer Z, options?: infer P) => infer R ? (name: Z, options?: P & WriteOptions) => R : F extends (x: any, arg_0: infer Z, options: infer P) => infer R ? (name: Z, options: P & WriteOptions) => R : never;
 interface WriteFunction<F extends (...args: any) => any> extends Function {
-    (...args: Parameters<OptionalWriteOptions<F>>): Promise<ContractTransaction>;
+    (...args: Parameters<OptionalWriteOptions<F>>): Promise<ContractTransaction & {
+        customData?: Record<string, any>;
+    }>;
     populateTransaction: (...args: Parameters<OptionalWriteOptions<F>>) => Promise<PopulatedTransaction>;
 }
 export declare type RawFunction = {
@@ -206,8 +211,8 @@ export declare class ENS {
             reverseResolverAddress: any;
             resolverAddress: any;
         } | {
-            name: null;
-            match: boolean;
+            name: undefined;
+            match?: undefined;
             reverseResolverAddress?: undefined;
             resolverAddress?: undefined;
         } | undefined>;
@@ -226,10 +231,9 @@ export declare class ENS {
         }>;
         decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
             fuseObj: {
-                [k: string]: any;
+                [k: string]: boolean;
             };
-            vulnerability: any;
-            vulnerableNode: null;
+            expiryDate: Date;
             rawFuses: ethers.BigNumber;
         } | undefined>;
     }>;
@@ -256,36 +260,6 @@ export declare class ENS {
             data: Record<string, any>;
         }[];
     } | undefined>;
-    getHistoryWithDetail: (name: string) => Promise<{
-        domain: {
-            type: any;
-            blockNumber: any;
-            transactionHash: any;
-            id: any;
-            data: Record<string, any>;
-        }[];
-        registration: {
-            type: any;
-            blockNumber: any;
-            transactionHash: any;
-            id: any;
-            data: Record<string, any>;
-        }[];
-        resolver: {
-            type: any;
-            blockNumber: any;
-            transactionHash: any;
-            id: any;
-            data: Record<string, any>;
-        }[];
-    } | undefined>;
-    getHistoryDetailForTransactionHash: (hash: string, indexInTransaction?: number | undefined) => Promise<({
-        key: any;
-        value: any;
-    } | undefined)[] | {
-        key: any;
-        value: any;
-    } | undefined>;
     getContentHash: GeneratedRawFunction<{
         raw: ({ contracts, universalWrapper }: ENSArgs<"contracts" | "universalWrapper">, name: string) => Promise<{
             to: string;
@@ -370,11 +344,18 @@ export declare class ENS {
         } | undefined>;
     }>;
     getExpiry: GeneratedRawFunction<{
-        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string) => Promise<{
+        raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: {
+            contract?: ("nameWrapper" | "registrar") | undefined;
+        }) => Promise<{
             to: string;
             data: string;
         }>;
-        decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string) => Promise<{
+        decode: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, { contract }?: {
+            contract?: ("nameWrapper" | "registrar") | undefined;
+        }) => Promise<{
+            expiry: Date;
+            gracePeriod: null;
+        } | {
             expiry: Date | null;
             gracePeriod: number;
         } | undefined>;
@@ -385,7 +366,7 @@ export declare class ENS {
         pageSize?: number | undefined;
         orderDirection?: "asc" | "desc" | undefined;
         orderBy?: "labelName" | "createdAt" | undefined;
-        lastSubnames: any[];
+        lastSubnames?: any[] | undefined;
         isLargeQuery?: boolean | undefined;
     }) => Promise<{
         subnames: {
@@ -429,6 +410,7 @@ export declare class ENS {
             premium: ethers.BigNumber;
         } | undefined>;
     }>;
+    getDNSOwner: (dnsName: string) => Promise<any>;
     universalWrapper: GeneratedRawFunction<{
         raw: ({ contracts }: ENSArgs<"contracts">, name: string, data: string) => Promise<{
             to: string;
@@ -467,6 +449,8 @@ export declare class ENS {
     createSubname: WriteFunction<typeof createSubname>;
     deleteSubname: WriteFunction<typeof deleteSubname>;
     transferSubname: WriteFunction<typeof transferSubname>;
-    getDNSOwner: (dnsName: string) => Promise<any>;
+    commitName: WriteFunction<typeof commitName>;
+    registerName: WriteFunction<typeof registerName>;
+    renewName: WriteFunction<typeof renewName>;
 }
 export {};

package/dist/cjs/index.js

@@ -205,8 +205,6 @@ class ENS {
         'contracts',
     ]);
     getHistory = this.generateFunction('getHistory', ['gqlInstance'], 'getHistory');
-    getHistoryWithDetail = this.generateFunction('getHistory', ['contracts', 'gqlInstance', 'provider'], 'getHistoryWithDetail');
-    getHistoryDetailForTransactionHash = this.generateFunction('getHistory', ['contracts', 'provider'], 'getHistoryDetailForTransactionHash');
     getContentHash = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getContentHash');
     _getContentHash = this.generateRawFunction('initialGetters', ['contracts'], '_getContentHash');
     getAddr = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getAddr');
@@ -218,6 +216,7 @@ class ENS {
     getSubnames = this.generateFunction('initialGetters', ['gqlInstance'], 'getSubnames');
     getNames = this.generateFunction('initialGetters', ['gqlInstance'], 'getNames');
     getPrice = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getPrice');
+    getDNSOwner = this.generateFunction('getDNSOwner', []);
     universalWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'universalWrapper');
     resolverMulticallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'resolverMulticallWrapper');
     multicallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'multicallWrapper');
@@ -234,14 +233,19 @@ class ENS {
     transferName = this.generateWriteFunction('transferName', ['contracts']);
     wrapName = this.generateWriteFunction('wrapName', [
         'contracts',
+        'getExpiry',
     ]);
     unwrapName = this.generateWriteFunction('unwrapName', ['contracts']);
     burnFuses = this.generateWriteFunction('burnFuses', [
         'contracts',
     ]);
-    createSubname = this.generateWriteFunction('createSubname', ['contracts']);
+    createSubname = this.generateWriteFunction('createSubname', ['contracts', 'getExpiry']);
     deleteSubname = this.generateWriteFunction('deleteSubname', ['transferSubname']);
-    transferSubname = this.generateWriteFunction('transferSubname', ['contracts']);
-    getDNSOwner = this.generateFunction('getDNSOwner', []);
+    transferSubname = this.generateWriteFunction('transferSubname', ['contracts', 'getExpiry']);
+    commitName = this.generateWriteFunction('commitName', ['contracts']);
+    registerName = this.generateWriteFunction('registerName', ['contracts']);
+    renewName = this.generateWriteFunction('renewName', [
+        'contracts',
+    ]);
 }
 exports.ENS = ENS;

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

@@ -1,26 +1,54 @@
 import type { FuseOptions } from '../@types/FuseOptions';
 import type { PublicResolver } from '../generated';
 import { RecordOptions } from './recordHelpers';
-export declare const randomSecret: () => string;
-export declare const makeCommitment: ({ name, owner, duration, resolver, records, reverseRecord, fuses, }: {
+export declare type RegistrationParams = {
     name: string;
     owner: string;
     duration: number;
+    secret: string;
     resolver: PublicResolver;
-    records?: RecordOptions | undefined;
-    reverseRecord?: boolean | undefined;
-    fuses?: FuseOptions | undefined;
-}) => {
+    records?: RecordOptions;
+    reverseRecord?: boolean;
+    fuses?: FuseOptions;
+    wrapperExpiry: number;
+};
+export declare type CommitmentParams = Omit<RegistrationParams, 'secret' | 'wrapperExpiry'> & {
+    secret?: string;
+    wrapperExpiry?: number;
+};
+export declare type RegistrationTuple = [
+    name: string,
+    owner: string,
+    duration: number,
+    secret: string,
+    resolver: string,
+    data: string[],
+    reverseRecord: boolean,
+    fuses: string,
+    wrapperExpiry: number
+];
+export declare type CommitmentTuple = [
+    labelhash: string,
+    owner: string,
+    duration: number,
+    resolver: string,
+    data: string[],
+    secret: string,
+    reverseRecord: boolean,
+    fuses: string,
+    wrapperExpiry: number
+];
+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;
+} & {
+    secret: string;
+}) => CommitmentTuple;
+export declare const makeRegistrationData: (params: RegistrationParams) => RegistrationTuple;
+export declare const makeCommitment: ({ secret, ...inputParams }: CommitmentParams) => {
     secret: string;
     commitment: string;
+    wrapperExpiry: number;
 };
-export declare const _makeCommitment: ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }: {
-    labelhash: string;
-    owner: string;
-    duration: number;
-    secret: string;
-    resolver: string;
-    data: string[];
-    reverseRecord: boolean;
-    fuses: string;
-}) => string;
+export declare const _makeCommitment: (params: CommitmentTuple) => string;

package/dist/cjs/utils/registerHelpers.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._makeCommitment = exports.makeCommitment = exports.randomSecret = void 0;
+exports._makeCommitment = exports.makeCommitment = exports.makeRegistrationData = exports.makeCommitmentData = exports.randomSecret = void 0;
 const ethers_1 = require("ethers");
 const generateFuseInput_1 = __importDefault(require("./generateFuseInput"));
 const labels_1 = require("./labels");
@@ -14,39 +14,67 @@ const randomSecret = () => {
     return '0x' + crypto.getRandomValues(bytes).toString('hex');
 };
 exports.randomSecret = randomSecret;
-const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
+const makeCommitmentData = ({ name, owner, duration, resolver, records, reverseRecord, fuses, wrapperExpiry, secret, }) => {
     const label = (0, labels_1.labelhash)(name.split('.')[0]);
     const hash = (0, normalise_1.namehash)(name);
     const resolverAddress = resolver.address;
-    const data = records ? (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver) : [];
-    const secret = (0, exports.randomSecret)();
     const fuseData = fuses ? (0, generateFuseInput_1.default)(fuses) : '0';
-    const commitment = (0, exports._makeCommitment)({
-        labelhash: label,
+    if (reverseRecord) {
+        if (!records) {
+            records = { coinTypes: [{ key: 'ETH', value: owner }] };
+        }
+        else if (!records.coinTypes?.find((c) => c.key === 'ETH')) {
+            if (!records.coinTypes)
+                records.coinTypes = [];
+            records.coinTypes.push({ key: 'ETH', value: owner });
+        }
+    }
+    const data = records ? (0, recordHelpers_1.generateRecordCallArray)(hash, records, resolver) : [];
+    return [
+        label,
         owner,
         duration,
-        secret,
-        resolver: resolverAddress,
+        resolverAddress,
         data,
-        reverseRecord: !!reverseRecord,
-        fuses: fuseData,
+        secret,
+        !!reverseRecord,
+        fuseData,
+        wrapperExpiry || Math.floor(Date.now() / 1000) + duration,
+    ];
+};
+exports.makeCommitmentData = makeCommitmentData;
+const makeRegistrationData = (params) => {
+    const commitmentData = (0, exports.makeCommitmentData)(params);
+    commitmentData[0] = params.name.split('.')[0];
+    const secret = commitmentData.splice(5, 1)[0];
+    commitmentData.splice(3, 0, secret);
+    return commitmentData;
+};
+exports.makeRegistrationData = makeRegistrationData;
+const makeCommitment = ({ secret = (0, exports.randomSecret)(), ...inputParams }) => {
+    const generatedParams = (0, exports.makeCommitmentData)({
+        ...inputParams,
+        secret,
     });
+    const commitment = (0, exports._makeCommitment)(generatedParams);
     return {
         secret,
         commitment,
+        wrapperExpiry: generatedParams[8],
     };
 };
 exports.makeCommitment = makeCommitment;
-const _makeCommitment = ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }) => {
-    return ethers_1.utils.solidityKeccak256([
+const _makeCommitment = (params) => {
+    return ethers_1.utils.keccak256(ethers_1.utils.defaultAbiCoder.encode([
         'bytes32',
         'address',
         'uint256',
-        'bytes32',
         'address',
         'bytes[]',
+        'bytes32',
         'bool',
-        'uint96',
-    ], [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses]);
+        'uint32',
+        'uint64',
+    ], params));
 };
 exports._makeCommitment = _makeCommitment;

package/dist/cjs/utils/wrapperExpiry.d.ts

@@ -0,0 +1,5 @@
+import { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+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 | undefined) => Promise<BigNumber>;

package/dist/cjs/utils/wrapperExpiry.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeExpiry = exports.MAX_EXPIRY = void 0;
+const ethers_1 = require("ethers");
+exports.MAX_EXPIRY = ethers_1.BigNumber.from(2).pow(64).sub(1);
+const makeExpiry = async ({ getExpiry }, name, expiry) => {
+    if (expiry) {
+        if (expiry instanceof Date) {
+            return ethers_1.BigNumber.from(expiry.getTime() / 1000);
+        }
+        else if (expiry instanceof ethers_1.BigNumber) {
+            return expiry;
+        }
+        else {
+            return ethers_1.BigNumber.from(expiry);
+        }
+    }
+    else {
+        if (name.endsWith('.eth')) {
+            const expResponse = await getExpiry(name);
+            if (!expResponse?.expiry)
+                throw new Error("Couldn't get expiry for name, please provide one.");
+            return ethers_1.BigNumber.from(expResponse.expiry.getTime() / 1000);
+        }
+        else {
+            return exports.MAX_EXPIRY;
+        }
+    }
+};
+exports.makeExpiry = makeExpiry;

package/dist/cjs/utils/writeTx.d.ts

@@ -1,4 +1,21 @@
 import { JsonRpcSigner } from '@ethersproject/providers';
 import type { PopulatedTransaction } from 'ethers';
-declare const _default: (signer: JsonRpcSigner, populate: boolean) => (tx: PopulatedTransaction) => PopulatedTransaction | Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
+declare type CustomData = Record<string, any>;
+declare const _default: (signer: JsonRpcSigner, populate: boolean) => ({ customData, ...tx }: PopulatedTransaction) => {
+    to?: string | undefined;
+    from?: string | undefined;
+    nonce?: number | undefined;
+    gasLimit?: import("ethers").BigNumber | undefined;
+    gasPrice?: import("ethers").BigNumber | undefined;
+    data?: string | undefined;
+    value?: import("ethers").BigNumber | undefined;
+    chainId?: number | undefined;
+    type?: number | undefined;
+    accessList?: import("ethers/lib/utils").AccessList | undefined;
+    maxFeePerGas?: import("ethers").BigNumber | undefined;
+    maxPriorityFeePerGas?: import("ethers").BigNumber | undefined;
+    ccipReadEnabled?: boolean | undefined;
+} | Promise<import("@ethersproject/providers").TransactionResponse | (import("@ethersproject/providers").TransactionResponse & {
+    customData: CustomData;
+})>;
 export default _default;

package/dist/cjs/utils/writeTx.js

@@ -1,3 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (signer, populate) => (tx) => populate ? tx : signer.sendTransaction(tx);
+const withCustomData = (tx, customData) => customData ? { ...tx, customData } : tx;
+exports.default = (signer, populate) => ({ customData, ...tx }) => populate
+    ? withCustomData(tx, customData)
+    : signer.sendTransaction(tx).then((r) => withCustomData(r, customData));

package/dist/esm/contracts/baseRegistrar.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").BaseRegistrarImplementation;
 export default _default;

package/dist/esm/contracts/index.d.ts

@@ -7,10 +7,10 @@ export default class ContractManager {
     private generateContractGetter;
     getPublicResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").PublicResolver>;
     getUniversalResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").UniversalResolver>;
-    getRegistry: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/ENSRegistry").ENSRegistry>;
+    getRegistry: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ENSRegistry>;
     getReverseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ReverseRegistrar>;
     getNameWrapper: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").NameWrapper>;
-    getBaseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation>;
+    getBaseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").BaseRegistrarImplementation>;
     getEthRegistrarController: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ETHRegistrarController>;
-    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/Multicall").Multicall>;
+    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").Multicall>;
 }

package/dist/esm/contracts/multicall.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/Multicall").Multicall;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").Multicall;
 export default _default;

package/dist/esm/contracts/registry.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/ENSRegistry").ENSRegistry;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ENSRegistry;
 export default _default;

package/dist/esm/functions/burnFuses.js

@@ -4,5 +4,5 @@ export default async function ({ contracts, signer }, name, { fusesToBurn, }) {
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     const hash = namehash(name);
     const encodedFuses = generateFuseInput(fusesToBurn);
-    return nameWrapper.populateTransaction.burnFuses(hash, encodedFuses);
+    return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
 }

package/dist/esm/functions/commitName.d.ts

@@ -0,0 +1,26 @@
+import { ENSArgs } from '..';
+import { CommitmentParams } from '../utils/registerHelpers';
+declare type Params = Omit<CommitmentParams, 'resolver' | 'name'> & {
+    resolverAddress?: string;
+};
+export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { resolverAddress, ...params }: Params): Promise<{
+    customData: {
+        secret: string;
+        commitment: string;
+        wrapperExpiry: number;
+    };
+    to?: string | undefined;
+    from?: string | undefined;
+    nonce?: number | undefined;
+    gasLimit?: import("ethers").BigNumber | undefined;
+    gasPrice?: import("ethers").BigNumber | undefined;
+    data?: string | undefined;
+    value?: import("ethers").BigNumber | undefined;
+    chainId?: number | undefined;
+    type?: number | undefined;
+    accessList?: import("ethers/lib/utils").AccessList | undefined;
+    maxFeePerGas?: import("ethers").BigNumber | undefined;
+    maxPriorityFeePerGas?: import("ethers").BigNumber | undefined;
+    ccipReadEnabled?: boolean | undefined;
+}>;
+export {};

package/dist/esm/functions/commitName.js

@@ -0,0 +1,21 @@
+import { makeCommitment } from '../utils/registerHelpers';
+export default async function ({ contracts }, name, { resolverAddress, ...params }) {
+    const labels = name.split('.');
+    if (labels.length !== 2 || labels[1] !== 'eth')
+        throw new Error('Currently only .eth TLD registrations are supported');
+    const controller = await contracts.getEthRegistrarController();
+    const resolver = await contracts.getPublicResolver(undefined, resolverAddress);
+    const { secret, commitment, wrapperExpiry } = makeCommitment({
+        name,
+        resolver,
+        ...params,
+    });
+    return {
+        ...(await controller.populateTransaction.commit(commitment)),
+        customData: {
+            secret,
+            commitment,
+            wrapperExpiry,
+        },
+    };
+}

package/dist/esm/functions/createSubname.d.ts

@@ -1,6 +1,7 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { FuseOptions } from '../@types/FuseOptions';
+import { Expiry } from '../utils/wrapperExpiry';
 declare type BaseArgs = {
     owner: string;
     resolverAddress?: string;
@@ -9,7 +10,8 @@ declare type BaseArgs = {
 declare type NameWrapperArgs = {
     contract: 'nameWrapper';
     fuses?: FuseOptions;
+    expiry?: Expiry;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<ethers.PopulatedTransaction>;
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<ethers.PopulatedTransaction>;
 export {};

package/dist/esm/functions/createSubname.js

@@ -1,7 +1,8 @@
 import { ethers } from 'ethers';
 import generateFuseInput from '../utils/generateFuseInput';
 import { namehash } from '../utils/normalise';
-export default async function ({ contracts, signer }, name, { owner, resolverAddress, contract, ...wrapperArgs }) {
+import { makeExpiry } from '../utils/wrapperExpiry';
+export default async function ({ contracts, signer, getExpiry, }, name, { owner, resolverAddress, contract, ...wrapperArgs }) {
     const labels = name.split('.');
     if (labels.length === 1) {
         throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs');
@@ -22,10 +23,11 @@ export default async function ({ contracts, signer }, name, { owner, resolverAdd
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            const expiry = await makeExpiry({ getExpiry }, name, 'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined);
             const generatedFuses = 'fuses' in wrapperArgs && wrapperArgs.fuses
                 ? generateFuseInput(wrapperArgs.fuses)
                 : '0';
-            return nameWrapper.populateTransaction.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses);
+            return nameWrapper.populateTransaction.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses, expiry);
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

package/dist/esm/functions/deleteSubname.d.ts

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

package/dist/esm/functions/deleteSubname.js

@@ -1,6 +1,7 @@
-export default async function ({ transferSubname }, name, { contract, }) {
+export default async function ({ transferSubname, signer }, name, { contract, }) {
     return transferSubname.populateTransaction(name, {
         contract,
-        address: '0x0000000000000000000000000000000000000000',
+        owner: '0x0000000000000000000000000000000000000000',
+        signer,
     });
 }

package/dist/esm/functions/getExpiry.d.ts

@@ -1,10 +1,17 @@
 import { ENSArgs } from '..';
+declare type ContractOption = 'registrar' | 'nameWrapper';
+declare type Args = {
+    contract?: ContractOption;
+};
 declare const _default: {
-    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string) => Promise<{
+    raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: Args) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string) => Promise<{
+    decode: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, { contract }?: Args) => Promise<{
+        expiry: Date;
+        gracePeriod: null;
+    } | {
         expiry: Date | null;
         gracePeriod: number;
     } | undefined>;