@ensdomains/ensjs 3.0.0-alpha.11 → 3.0.0-alpha.14

package/dist/esm/functions/getHistory.js

@@ -1,7 +1,6 @@
 import { formatsByCoinType } from '@ensdomains/address-encoder';
 import { ethers } from 'ethers';
 import { decodeContenthash } from '../utils/contentHash';
-import { makeOtherIndexes } from '../utils/makeHashIndexes';
 const eventFormat = {
     Domain: {
         NewOwner: (args) => ({ owner: args.owner.id }),
@@ -43,7 +42,7 @@ const eventFormat = {
         NameChanged: (args) => ({ name: args.name }),
         AbiChanged: (args) => ({ contentType: args.contentType }),
         PubkeyChanged: (args) => ({ x: args.x, y: args.y }),
-        TextChanged: (args) => ({ key: args.key }),
+        TextChanged: (args) => ({ key: args.key, value: args.value }),
         ContenthashChanged: (args) => ({ hash: decodeContenthash(args.hash) }),
         InterfaceChanged: (args) => ({
             interfaceId: args.interfaceId,
@@ -63,31 +62,6 @@ const mapEvents = (eventArray, type) => eventArray.map((event) => ({
     id: event.id,
     data: eventFormat[type][event.__typename](event),
 }));
-const mapResultDetailDecode = (publicResolver) => (result) => {
-    const hashIndexes = makeOtherIndexes(result.input, '10f13a8c');
-    const abiLengths = hashIndexes.map((x) => ({
-        index: x,
-        length: x === 0
-            ? ethers.utils.hexDataLength(result.input)
-            : parseInt(ethers.utils.hexDataSlice(result.input, x - 32, x), 16),
-    }));
-    const ABIs = abiLengths.map(({ index, length }) => ethers.utils.hexDataSlice(result.input, index, index + length));
-    return ABIs.map((abi) => {
-        try {
-            return publicResolver.interface.decodeFunctionData('setText(bytes32,string,string)', abi);
-        }
-        catch {
-            return;
-        }
-    });
-};
-const expandDecode = (prev, curr) => {
-    if (!curr)
-        return [...prev, { value: null }];
-    if (!curr.length)
-        return [...prev, curr];
-    return [...prev, ...curr];
-};
 export async function getHistory({ gqlInstance }, name) {
     const client = gqlInstance.client;
     const query = gqlInstance.gql `
@@ -168,6 +142,7 @@ export async function getHistory({ gqlInstance }, name) {
               }
               ...on TextChanged {
                 key
+                value
               }
               ...on ContenthashChanged {
                 hash
@@ -202,72 +177,3 @@ export async function getHistory({ gqlInstance }, name) {
         resolver: resolverHistory,
     };
 }
-export async function getHistoryWithDetail({ contracts, gqlInstance, provider, }, name) {
-    const historyRes = await getHistory({ gqlInstance }, name);
-    if (!historyRes)
-        return;
-    const { domain, registration, resolver: resolverHistory } = historyRes;
-    const textEvents = resolverHistory.filter((event) => event.type === 'TextChanged');
-    const transactions = textEvents.reduce((prev, curr) => {
-        if (prev.includes(curr.transactionHash)) {
-            return prev;
-        }
-        return [...prev, curr.transactionHash];
-    }, []);
-    const publicResolver = await contracts?.getPublicResolver();
-    const fetchResult = (await ethers.utils.fetchJson(provider.connection, JSON.stringify(transactions.map((tx, i) => ({
-        jsonrpc: '2.0',
-        id: i,
-        method: 'eth_getTransactionByHash',
-        params: [tx],
-    })))))
-        .map((result) => result.result)
-        .map(mapResultDetailDecode(publicResolver))
-        .reduce(expandDecode, []);
-    const detailedResolverHistory = resolverHistory.map((event) => {
-        if (event.type !== 'TextChanged')
-            return event;
-        const { id } = event;
-        const matchedTextInx = textEvents.findIndex((x) => x.id === id);
-        return {
-            ...event,
-            data: {
-                ...event.data,
-                value: fetchResult[matchedTextInx] && fetchResult[matchedTextInx].value,
-            },
-        };
-    });
-    return {
-        domain,
-        registration,
-        resolver: detailedResolverHistory,
-    };
-}
-export async function getHistoryDetailForTransactionHash({ contracts, provider }, hash, indexInTransaction) {
-    const publicResolver = await contracts?.getPublicResolver();
-    const transaction = await provider.getTransaction(hash);
-    if (!transaction)
-        return;
-    const result = mapResultDetailDecode(publicResolver)({
-        input: transaction.data,
-    });
-    if (!result || !result.length)
-        return;
-    if (typeof indexInTransaction === 'number') {
-        if (indexInTransaction + 1 > result.length)
-            return;
-        const resultItem = result[indexInTransaction];
-        if (!resultItem ||
-            !resultItem.key ||
-            (!resultItem.value && resultItem.value !== ''))
-            return;
-        return { key: resultItem.key, value: resultItem.value };
-    }
-    return result.map((item) => {
-        if (!item.key)
-            return;
-        if (!item.value && item.value !== '')
-            return { key: item.key, value: null };
-        return { key: item.key, value: item.value };
-    });
-}

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

@@ -10,8 +10,8 @@ declare const _default: {
         reverseResolverAddress: any;
         resolverAddress: any;
     } | {
-        name: null;
-        match: boolean;
+        name: undefined;
+        match?: undefined;
         reverseResolverAddress?: undefined;
         resolverAddress?: undefined;
     } | undefined>;

package/dist/esm/functions/getName.js

@@ -23,7 +23,7 @@ const decode = async ({ contracts }, data, address) => {
         };
     }
     catch {
-        return { name: null, match: false };
+        return { name: undefined };
     }
 };
 export default {

package/dist/esm/functions/getProfile.js

@@ -215,7 +215,7 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress)
         resolverResponse = domain?.resolver;
     }
     else {
-        const resolverId = `${resolverAddress}-${id}`;
+        const resolverId = `${resolverAddress.toLowerCase()}-${id}`;
         ({ resolver: resolverResponse, domain } = await client.request(customResolverQuery, { id, resolverId }));
     }
     if (!domain)

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

@@ -52,21 +52,21 @@ export declare const getText: {
     decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string) => Promise<any>;
 };
 export declare const _getAddr: {
-    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, coinType?: string | number | undefined, bypassFormat?: boolean | undefined) => Promise<{
+    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, coinType?: string | number, bypassFormat?: boolean) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
+    decode: ({ contracts }: ENSArgs<'contracts'>, data: string, _name: string, coinType?: string | number) => Promise<string | {
         coin: string;
         addr: string;
     } | undefined>;
 };
 export declare const getAddr: {
-    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, coinType?: string | number | undefined) => Promise<{
+    raw: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, name: string, coinType?: string | number) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string, _name: string, coinType?: string | number | undefined) => Promise<string | {
+    decode: ({ contracts, universalWrapper }: ENSArgs<'contracts' | 'universalWrapper'>, data: string, _name: string, coinType?: string | number) => Promise<string | {
         coin: string;
         addr: string;
     } | undefined>;

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

@@ -0,0 +1,11 @@
+import { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+import { CommitmentParams } from '../utils/registerHelpers';
+declare type Params = Omit<CommitmentParams, 'name' | 'resolver'> & {
+    resolverAddress?: string;
+    secret: string;
+    wrapperExpiry: number;
+    value: BigNumber;
+};
+export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { resolverAddress, value, ...params }: Params): Promise<import("ethers").PopulatedTransaction>;
+export {};

package/dist/esm/functions/registerName.js

@@ -0,0 +1,16 @@
+import { makeRegistrationData, } from '../utils/registerHelpers';
+export default async function ({ contracts }, name, { resolverAddress, value, ...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 generatedParams = makeRegistrationData({
+        name,
+        resolver: _resolver,
+        ...params,
+    });
+    return controller.populateTransaction.register(...generatedParams, {
+        value,
+    });
+}

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

@@ -0,0 +1,6 @@
+import type { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { duration, value, }: {
+    duration: number;
+    value: BigNumber;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/renewName.js

@@ -0,0 +1,7 @@
+export default async function ({ contracts }, name, { duration, value, }) {
+    const labels = name.split('.');
+    if (labels.length !== 2 || labels[1] !== 'eth')
+        throw new Error('Currently only .eth TLD renewals are supported');
+    const controller = await contracts.getEthRegistrarController();
+    return controller.populateTransaction.renew(labels[0], duration, { value });
+}

package/dist/esm/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 = {
@@ -70,6 +75,16 @@ export declare class ENS {
     contracts?: ContractManager;
     getContractAddress: (networkId: SupportedNetworkId) => import("./contracts/getContractAddress").ContractAddressFetch;
     gqlInstance: GqlManager;
+    fuses: {
+        CAN_DO_EVERYTHING: number;
+        CANNOT_UNWRAP: 1;
+        CANNOT_BURN_FUSES: 2;
+        CANNOT_TRANSFER: 4;
+        CANNOT_SET_RESOLVER: 8;
+        CANNOT_SET_TTL: 16;
+        CANNOT_CREATE_SUBDOMAIN: 32;
+        PARENT_CANNOT_CONTROL: 64;
+    };
     constructor(options?: ENSOptions);
     /**
      * Checks for an initial provider and if it exists, sets it as the provider
@@ -206,8 +221,8 @@ export declare class ENS {
             reverseResolverAddress: any;
             resolverAddress: any;
         } | {
-            name: null;
-            match: boolean;
+            name: undefined;
+            match?: undefined;
             reverseResolverAddress?: undefined;
             resolverAddress?: undefined;
         } | undefined>;
@@ -224,12 +239,13 @@ export declare class ENS {
             to: string;
             data: string;
         }>;
-        decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
+        decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<{
             fuseObj: {
                 [k: string]: boolean;
             };
             expiryDate: Date;
             rawFuses: ethers.BigNumber;
+            owner: any;
         } | undefined>;
     }>;
     getHistory: (name: string) => Promise<{
@@ -255,36 +271,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;
@@ -435,6 +421,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;
@@ -473,6 +460,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/esm/index.js

@@ -3,6 +3,7 @@ import { getContractAddress as _getContractAddress } from './contracts/getContra
 import GqlManager from './GqlManager';
 import singleCall from './utils/singleCall';
 import writeTx from './utils/writeTx';
+import fuseEnum from './utils/fuses';
 const graphURIEndpoints = {
     1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
     3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -13,6 +14,7 @@ export class ENS {
     constructor(options) {
         this.getContractAddress = _getContractAddress;
         this.gqlInstance = new GqlManager();
+        this.fuses = fuseEnum;
         /**
          * Checks for an initial provider and if it exists, sets it as the provider
          * @returns {Promise<void>} - A promise that resolves when the provider is checked, and set if needed
@@ -168,8 +170,6 @@ export class ENS {
             'contracts',
         ]);
         this.getHistory = this.generateFunction('getHistory', ['gqlInstance'], 'getHistory');
-        this.getHistoryWithDetail = this.generateFunction('getHistory', ['contracts', 'gqlInstance', 'provider'], 'getHistoryWithDetail');
-        this.getHistoryDetailForTransactionHash = this.generateFunction('getHistory', ['contracts', 'provider'], 'getHistoryDetailForTransactionHash');
         this.getContentHash = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getContentHash');
         this._getContentHash = this.generateRawFunction('initialGetters', ['contracts'], '_getContentHash');
         this.getAddr = this.generateRawFunction('initialGetters', ['contracts', 'universalWrapper'], 'getAddr');
@@ -181,6 +181,7 @@ export class ENS {
         this.getSubnames = this.generateFunction('initialGetters', ['gqlInstance'], 'getSubnames');
         this.getNames = this.generateFunction('initialGetters', ['gqlInstance'], 'getNames');
         this.getPrice = this.generateRawFunction('initialGetters', ['contracts', 'multicallWrapper'], 'getPrice');
+        this.getDNSOwner = this.generateFunction('getDNSOwner', []);
         this.universalWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'universalWrapper');
         this.resolverMulticallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'resolverMulticallWrapper');
         this.multicallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'multicallWrapper');
@@ -206,7 +207,11 @@ export class ENS {
         this.createSubname = this.generateWriteFunction('createSubname', ['contracts', 'getExpiry']);
         this.deleteSubname = this.generateWriteFunction('deleteSubname', ['transferSubname']);
         this.transferSubname = this.generateWriteFunction('transferSubname', ['contracts', 'getExpiry']);
-        this.getDNSOwner = this.generateFunction('getDNSOwner', []);
+        this.commitName = this.generateWriteFunction('commitName', ['contracts']);
+        this.registerName = this.generateWriteFunction('registerName', ['contracts']);
+        this.renewName = this.generateWriteFunction('renewName', [
+            'contracts',
+        ]);
         this.options = options;
         this.getContractAddress = options?.getContractAddress || _getContractAddress;
     }

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

@@ -1,20 +1,21 @@
-export declare const testable: {
-    CANNOT_UNWRAP: number;
-    CANNOT_BURN_FUSES: number;
-    CANNOT_TRANSFER: number;
-    CANNOT_SET_RESOLVER: number;
-    CANNOT_SET_TTL: number;
-    CANNOT_CREATE_SUBDOMAIN: number;
-    PARENT_CANNOT_CONTROL: number;
+export declare const fuseEnum: {
+    readonly CANNOT_UNWRAP: 1;
+    readonly CANNOT_BURN_FUSES: 2;
+    readonly CANNOT_TRANSFER: 4;
+    readonly CANNOT_SET_RESOLVER: 8;
+    readonly CANNOT_SET_TTL: 16;
+    readonly CANNOT_CREATE_SUBDOMAIN: 32;
+    readonly PARENT_CANNOT_CONTROL: 64;
 };
-declare const _default: {
+export declare const unnamedFuses: readonly [128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296];
+declare const fullFuseEnum: {
     CAN_DO_EVERYTHING: number;
-    CANNOT_UNWRAP: number;
-    CANNOT_BURN_FUSES: number;
-    CANNOT_TRANSFER: number;
-    CANNOT_SET_RESOLVER: number;
-    CANNOT_SET_TTL: number;
-    CANNOT_CREATE_SUBDOMAIN: number;
-    PARENT_CANNOT_CONTROL: number;
+    CANNOT_UNWRAP: 1;
+    CANNOT_BURN_FUSES: 2;
+    CANNOT_TRANSFER: 4;
+    CANNOT_SET_RESOLVER: 8;
+    CANNOT_SET_TTL: 16;
+    CANNOT_CREATE_SUBDOMAIN: 32;
+    PARENT_CANNOT_CONTROL: 64;
 };
-export default _default;
+export default fullFuseEnum;

package/dist/esm/utils/fuses.js

@@ -6,7 +6,7 @@ const CANNOT_SET_TTL = 16;
 const CANNOT_CREATE_SUBDOMAIN = 32;
 const PARENT_CANNOT_CONTROL = 64;
 const CAN_DO_EVERYTHING = 0;
-export const testable = {
+export const fuseEnum = {
     CANNOT_UNWRAP,
     CANNOT_BURN_FUSES,
     CANNOT_TRANSFER,
@@ -15,7 +15,13 @@ export const testable = {
     CANNOT_CREATE_SUBDOMAIN,
     PARENT_CANNOT_CONTROL,
 };
-export default {
-    ...testable,
+export const unnamedFuses = [
+    128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
+    524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864,
+    134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296,
+];
+const fullFuseEnum = {
+    ...fuseEnum,
     CAN_DO_EVERYTHING,
 };
+export default fullFuseEnum;

package/dist/esm/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/esm/utils/registerHelpers.js

@@ -7,37 +7,63 @@ export const randomSecret = () => {
     const bytes = Buffer.allocUnsafe(32);
     return '0x' + crypto.getRandomValues(bytes).toString('hex');
 };
-export const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
+export const makeCommitmentData = ({ name, owner, duration, resolver, records, reverseRecord, fuses, wrapperExpiry, secret, }) => {
     const label = labelhash(name.split('.')[0]);
     const hash = namehash(name);
     const resolverAddress = resolver.address;
-    const data = records ? generateRecordCallArray(hash, records, resolver) : [];
-    const secret = randomSecret();
     const fuseData = fuses ? generateFuseInput(fuses) : '0';
-    const commitment = _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 ? 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,
+    ];
+};
+export const makeRegistrationData = (params) => {
+    const commitmentData = makeCommitmentData(params);
+    commitmentData[0] = params.name.split('.')[0];
+    const secret = commitmentData.splice(5, 1)[0];
+    commitmentData.splice(3, 0, secret);
+    return commitmentData;
+};
+export const makeCommitment = ({ secret = randomSecret(), ...inputParams }) => {
+    const generatedParams = makeCommitmentData({
+        ...inputParams,
+        secret,
     });
+    const commitment = _makeCommitment(generatedParams);
     return {
         secret,
         commitment,
+        wrapperExpiry: generatedParams[8],
     };
 };
-export const _makeCommitment = ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }) => {
-    return utils.solidityKeccak256([
+export const _makeCommitment = (params) => {
+    return utils.keccak256(utils.defaultAbiCoder.encode([
         'bytes32',
         'address',
         'uint256',
-        'bytes32',
         'address',
         'bytes[]',
+        'bytes32',
         'bool',
-        'uint96',
-    ], [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses]);
+        'uint32',
+        'uint64',
+    ], params));
 };

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

@@ -2,4 +2,4 @@ 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>;
+export declare const makeExpiry: ({ getExpiry }: ENSArgs<'getExpiry'>, name: string, expiry?: Expiry) => Promise<BigNumber>;

package/dist/esm/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/esm/utils/writeTx.js

@@ -1 +1,4 @@
-export default (signer, populate) => (tx) => populate ? tx : signer.sendTransaction(tx);
+const withCustomData = (tx, customData) => customData ? { ...tx, customData } : tx;
+export default (signer, populate) => ({ customData, ...tx }) => populate
+    ? withCustomData(tx, customData)
+    : signer.sendTransaction(tx).then((r) => withCustomData(r, customData));