@ensdomains/ensjs 3.0.0-alpha.1 → 3.0.0-alpha.12

package/dist/esm/index.d.ts

@@ -1,7 +1,19 @@
-import { ethers } from 'ethers';
+import { JsonRpcSigner } from '@ethersproject/providers';
+import { ContractTransaction, ethers, PopulatedTransaction } from 'ethers';
 import ContractManager from './contracts';
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
 import { SupportedNetworkId } from './contracts/types';
+import type burnFuses from './functions/burnFuses';
+import type createSubname from './functions/createSubname';
+import type deleteSubname from './functions/deleteSubname';
+import type setName from './functions/setName';
+import type setRecord from './functions/setRecord';
+import type setRecords from './functions/setRecords';
+import type setResolver from './functions/setResolver';
+import type transferName from './functions/transferName';
+import type transferSubname from './functions/transferSubname';
+import type unwrapName from './functions/unwrapName';
+import type wrapName from './functions/wrapName';
 import GqlManager from './GqlManager';
 declare type ENSOptions = {
     graphURI?: string | null;
@@ -10,6 +22,7 @@ declare type ENSOptions = {
 export declare type InternalENS = {
     options?: ENSOptions;
     provider?: ethers.providers.Provider;
+    signer: JsonRpcSigner;
     graphURI?: string | null;
 } & ENS;
 export declare type ENSArgs<K extends keyof InternalENS> = {
@@ -17,6 +30,15 @@ export declare type ENSArgs<K extends keyof InternalENS> = {
 };
 declare type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never;
 declare type OmitFirstTwoArgs<F> = F extends (x: any, y: any, ...args: infer P) => infer R ? (...args: P) => R : never;
+declare type WriteOptions = {
+    addressOrIndex?: string | number;
+    signer?: JsonRpcSigner;
+};
+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>;
+    populateTransaction: (...args: Parameters<OptionalWriteOptions<F>>) => Promise<PopulatedTransaction>;
+}
 export declare type RawFunction = {
     raw: (...args: any[]) => Promise<{
         to: string;
@@ -77,6 +99,14 @@ export declare class ENS {
      * @returns {OmitFirstArg} - The generated wrapped function
      */
     private generateFunction;
+    /**
+     * Generates a write wrapped function
+     * @param {string} path - The path of the exported function
+     * @param {FunctionDeps} dependencies - An array of ENS properties
+     * @param {string} exportName - The export name of the target function
+     * @returns {OmitFirstArg} - The generated wrapped function
+     */
+    private generateWriteFunction;
     /**
      * Generates a wrapped function from raw and decode exports
      * @param {string} path - The path of the exported function
@@ -104,11 +134,13 @@ export declare class ENS {
         }>;
         decode: ({ multicallWrapper }: ENSArgs<"multicallWrapper">, data: string, ...items: BatchFunctionResult<RawFunction>[]) => Promise<any[] | undefined>;
     }>;
-    getProfile: (nameOrAddress: string, options?: {
+    getProfile: (nameOrAddress: string, options?: ({
         contentHash?: boolean | undefined;
         texts?: boolean | string[] | undefined;
         coinTypes?: boolean | string[] | undefined;
-    } | undefined) => Promise<{
+    } & {
+        resolverAddress?: string | undefined;
+    }) | undefined) => Promise<{
         isMigrated: boolean | null;
         createdAt: string | null;
         address?: string | undefined;
@@ -137,6 +169,7 @@ export declare class ENS {
         contentHash?: boolean | undefined;
         texts?: boolean | string[] | undefined;
         coinTypes?: boolean | string[] | undefined;
+        resolverAddress?: string | undefined;
     } | undefined) => Promise<{
         isMigrated: boolean | null;
         createdAt: string | null;
@@ -173,8 +206,8 @@ export declare class ENS {
             reverseResolverAddress: any;
             resolverAddress: any;
         } | {
-            name: null;
-            match: boolean;
+            name: undefined;
+            match?: undefined;
             reverseResolverAddress?: undefined;
             resolverAddress?: undefined;
         } | undefined>;
@@ -193,10 +226,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>;
     }>;
@@ -223,36 +255,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;
@@ -337,11 +339,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>;
@@ -352,7 +361,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: {
@@ -423,48 +432,17 @@ export declare class ENS {
         }>;
         decode: ({ contracts }: ENSArgs<"contracts">, data: string) => Promise<any>;
     }>;
-    setName: (name: string, address?: string | undefined, resolver?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction | undefined>;
-    setRecords: (name: string, records: import("./utils/recordHelpers").RecordOptions) => Promise<ethers.ContractTransaction | undefined>;
-    setResolver: (name: string, contract: "nameWrapper" | "registry", resolver?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    transferName: (name: string, newOwner: string, contract: "nameWrapper" | "registry" | "baseRegistrar", options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    wrapName: (name: string, wrappedOwner: string, fuseOptions?: string | number | import("./@types/FuseOptions").FuseOptions | undefined, resolverAddress?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    unwrapName: (name: string, newController: string, newRegistrant?: string | undefined, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    burnFuses: (name: string, fusesToBurn: import("./@types/FuseOptions").FuseOptions) => Promise<ethers.ContractTransaction>;
-    createSubname: (args_0: {
-        name: string;
-        owner: string;
-        resolverAddress?: string | undefined;
-        contract: "nameWrapper" | "registry";
-        options?: {
-            addressOrIndex?: string | number | undefined;
-        } | undefined;
-    } | ({
-        contract: "nameWrapper";
-        fuses?: import("./@types/FuseOptions").FuseOptions | undefined;
-    } & {
-        name: string;
-        owner: string;
-        resolverAddress?: string | undefined;
-        contract: "nameWrapper" | "registry";
-        options?: {
-            addressOrIndex?: string | number | undefined;
-        } | undefined;
-    })) => Promise<ethers.ContractTransaction>;
-    deleteSubname: (name: string, contract: "nameWrapper" | "registry", options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
-    transferSubname: (name: string, contract: "nameWrapper" | "registry", address: string, options?: {
-        addressOrIndex?: string | number | undefined;
-    } | undefined) => Promise<ethers.ContractTransaction>;
+    setName: WriteFunction<typeof setName>;
+    setRecords: WriteFunction<typeof setRecords>;
+    setRecord: WriteFunction<typeof setRecord>;
+    setResolver: WriteFunction<typeof setResolver>;
+    transferName: WriteFunction<typeof transferName>;
+    wrapName: WriteFunction<typeof wrapName>;
+    unwrapName: WriteFunction<typeof unwrapName>;
+    burnFuses: WriteFunction<typeof burnFuses>;
+    createSubname: WriteFunction<typeof createSubname>;
+    deleteSubname: WriteFunction<typeof deleteSubname>;
+    transferSubname: WriteFunction<typeof transferSubname>;
+    getDNSOwner: (dnsName: string) => Promise<any>;
 }
 export {};

package/dist/esm/index.js

@@ -2,6 +2,7 @@ import ContractManager from './contracts';
 import { getContractAddress as _getContractAddress } from './contracts/getContractAddress';
 import GqlManager from './GqlManager';
 import singleCall from './utils/singleCall';
+import writeTx from './utils/writeTx';
 const graphURIEndpoints = {
     1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
     3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -52,15 +53,30 @@ export class ENS {
                 await thisRef.checkInitialProvider();
                 // import the module dynamically
                 const mod = await import(
-                /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true */
+                /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
                 `./functions/${path}`);
                 // if combine isn't specified, run normally
                 // otherwise, create a function from the raw and decode functions
                 if (subFunc !== 'combine') {
+                    const writeable = subFunc === 'write' || subFunc === 'populateTransaction';
                     // get the function to call
-                    const func = subFunc ? mod[exportName][subFunc] : mod[exportName];
+                    const func = subFunc && !writeable ? mod[exportName][subFunc] : mod[exportName];
                     // get the dependencies to forward to the function as the first arg
-                    const dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
+                    let dependenciesToForward = thisRef.forwardDependenciesFromArray(dependencies);
+                    // if func is write func, inject signer into dependencies
+                    if (writeable) {
+                        const options = (args[1] || {});
+                        const signer = options.signer ||
+                            thisRef.provider?.getSigner(options.addressOrIndex);
+                        const populate = subFunc === 'populateTransaction';
+                        if (!signer) {
+                            throw new Error('No signer specified');
+                        }
+                        delete options.addressOrIndex;
+                        delete options.signer;
+                        dependenciesToForward = { ...dependenciesToForward, signer };
+                        return func(dependenciesToForward, args[0], options).then(writeTx(signer, populate));
+                    }
                     // return the function with the dependencies forwarded
                     return func(dependenciesToForward, ...args);
                 }
@@ -77,6 +93,9 @@ export class ENS {
                 mainFunc.decode = this.importGenerator(path, dependencies, exportName, 'decode');
                 mainFunc.batch = this.importGenerator(path, dependencies, exportName, 'batch', { raw: mainFunc.raw, decode: mainFunc.decode });
             }
+            else if (subFunc === 'write') {
+                mainFunc.populateTransaction = this.importGenerator(path, dependencies, exportName, 'populateTransaction');
+            }
             return mainFunc;
         };
         /**
@@ -87,6 +106,14 @@ export class ENS {
          * @returns {OmitFirstArg} - The generated wrapped function
          */
         this.generateFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName);
+        /**
+         * Generates a write wrapped function
+         * @param {string} path - The path of the exported function
+         * @param {FunctionDeps} dependencies - An array of ENS properties
+         * @param {string} exportName - The export name of the target function
+         * @returns {OmitFirstArg} - The generated wrapped function
+         */
+        this.generateWriteFunction = (path, dependencies, exportName = 'default') => this.importGenerator(path, dependencies, exportName, 'write');
         /**
          * Generates a wrapped function from raw and decode exports
          * @param {string} path - The path of the exported function
@@ -129,6 +156,7 @@ export class ENS {
             'gqlInstance',
             'getName',
             'resolverMulticallWrapper',
+            'multicallWrapper',
             '_getAddr',
             '_getContentHash',
             '_getText',
@@ -140,8 +168,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');
@@ -156,32 +182,29 @@ export class ENS {
         this.universalWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'universalWrapper');
         this.resolverMulticallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'resolverMulticallWrapper');
         this.multicallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'multicallWrapper');
-        this.setName = this.generateFunction('setName', [
+        this.setName = this.generateWriteFunction('setName', [
             'contracts',
-            'provider',
         ]);
-        this.setRecords = this.generateFunction('setRecords', [
+        this.setRecords = this.generateWriteFunction('setRecords', ['contracts', 'provider', 'getResolver']);
+        this.setRecord = this.generateWriteFunction('setRecord', [
             'contracts',
             'provider',
             'getResolver',
         ]);
-        this.setResolver = this.generateFunction('setResolver', ['contracts', 'provider']);
-        this.transferName = this.generateFunction('transferName', ['contracts', 'provider']);
-        this.wrapName = this.generateFunction('wrapName', [
+        this.setResolver = this.generateWriteFunction('setResolver', ['contracts']);
+        this.transferName = this.generateWriteFunction('transferName', ['contracts']);
+        this.wrapName = this.generateWriteFunction('wrapName', [
             'contracts',
-            'provider',
+            'getExpiry',
         ]);
-        this.unwrapName = this.generateFunction('unwrapName', [
+        this.unwrapName = this.generateWriteFunction('unwrapName', ['contracts']);
+        this.burnFuses = this.generateWriteFunction('burnFuses', [
             'contracts',
-            'provider',
-        ]);
-        this.burnFuses = this.generateFunction('burnFuses', [
-            'contracts',
-            'provider',
         ]);
-        this.createSubname = this.generateFunction('createSubname', ['contracts', 'provider']);
-        this.deleteSubname = this.generateFunction('deleteSubname', ['contracts', 'provider', 'transferSubname']);
-        this.transferSubname = this.generateFunction('transferSubname', ['contracts', 'provider']);
+        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.options = options;
         this.getContractAddress = options?.getContractAddress || _getContractAddress;
     }

package/dist/esm/utils/labels.js

@@ -1,5 +1,6 @@
 import { solidityKeccak256 } from 'ethers/lib/utils';
 import { truncateFormat } from './format';
+const hasLocalStorage = typeof localStorage !== 'undefined';
 export const labelhash = (input) => solidityKeccak256(['string'], [input]);
 export const keccakFromString = (input) => labelhash(input);
 export function decodeLabelhash(hash) {
@@ -9,7 +10,7 @@ export function decodeLabelhash(hash) {
     if (hash.length !== 66) {
         throw Error('Expected encoded labelhash to have a length of 66');
     }
-    return `${hash.slice(1, -1)}`;
+    return `0x${hash.slice(1, -1)}`;
 }
 export function encodeLabelhash(hash) {
     if (!hash.startsWith('0x')) {
@@ -24,12 +25,12 @@ export function isEncodedLabelhash(hash) {
     return hash.startsWith('[') && hash.endsWith(']') && hash.length === 66;
 }
 function getLabels() {
-    return localStorage
+    return hasLocalStorage
         ? JSON.parse(localStorage.getItem('ensjs:labels')) || {}
         : {};
 }
 function _saveLabel(hash, label) {
-    if (!localStorage)
+    if (!hasLocalStorage)
         return hash;
     const labels = getLabels();
     localStorage.setItem('ensjs:labels', JSON.stringify({
@@ -81,7 +82,7 @@ export function decryptName(name) {
 }
 export const truncateUndecryptedName = (name) => truncateFormat(name);
 export function checkLocalStorageSize() {
-    if (!localStorage)
+    if (!hasLocalStorage)
         return 'Empty (0 KB)';
     let allStrings = '';
     for (const key in window.localStorage) {

package/dist/esm/utils/makeHashIndexes.js

@@ -1,3 +1,3 @@
-import { ethers } from 'ethers';
+import { namehash } from './normalise';
 export const makeOtherIndexes = (data, findStr) => Array.from(data.matchAll(findStr)).map((x) => x.index / 2 - 1);
-export const makeNamehashIndexes = (data, name) => Array.from(data.matchAll(ethers.utils.namehash(name).substring(2))).map((x) => x.index / 2 - 1);
+export const makeNamehashIndexes = (data, name) => Array.from(data.matchAll(namehash(name).substring(2))).map((x) => x.index / 2 - 1);

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

@@ -1 +1,2 @@
 export declare const normalise: (name: string) => any;
+export declare const namehash: (name: string) => string;

package/dist/esm/utils/normalise.js

@@ -1,2 +1,27 @@
+import { concat, hexlify, keccak256, toUtf8Bytes } from 'ethers/lib/utils';
 import uts46 from 'idna-uts46-hx/uts46bundle.js';
+import { decodeLabelhash, isEncodedLabelhash } from './labels';
+const zeros = new Uint8Array(32);
+zeros.fill(0);
 export const normalise = (name) => name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name;
+export const namehash = (name) => {
+    let result = zeros;
+    if (name) {
+        const labels = name.split('.');
+        for (var i = labels.length - 1; i >= 0; i--) {
+            let labelSha;
+            if (isEncodedLabelhash(labels[i])) {
+                labelSha = decodeLabelhash(labels[i]);
+            }
+            else {
+                const normalised = normalise(labels[i]);
+                labelSha = keccak256(toUtf8Bytes(normalised));
+            }
+            result = keccak256(concat([result, labelSha]));
+        }
+    }
+    else {
+        result = hexlify(zeros);
+    }
+    return result;
+};

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

@@ -9,5 +9,8 @@ export declare type RecordOptions = {
     coinTypes?: RecordItem[];
 };
 export declare const generateSetAddr: (namehash: string, coinType: string, address: string, resolver: PublicResolver) => string;
+export declare type RecordTypes = 'contentHash' | 'text' | 'addr';
+export declare type RecordInput<T extends RecordTypes> = T extends 'contentHash' ? string : RecordItem;
+export declare function generateSingleRecordCall<T extends RecordTypes>(namehash: string, resolver: PublicResolver, type: T): (record: RecordInput<T>) => string;
 export declare const generateRecordCallArray: (namehash: string, records: RecordOptions, resolver: PublicResolver) => string[];
 export {};

package/dist/esm/utils/recordHelpers.js

@@ -12,28 +12,54 @@ export const generateSetAddr = (namehash, coinType, address, resolver) => {
     const encodedAddress = coinTypeInstance.decoder(address);
     return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
 };
+export function generateSingleRecordCall(namehash, resolver, type) {
+    if (type === 'contentHash') {
+        return (_r) => {
+            const record = _r;
+            let _contentHash = '';
+            if (record !== _contentHash) {
+                const encoded = encodeContenthash(record);
+                if (encoded.error)
+                    throw new Error(encoded.error);
+                _contentHash = encoded.encoded;
+            }
+            return resolver.interface.encodeFunctionData('setContenthash', [
+                namehash,
+                _contentHash,
+            ]);
+        };
+    }
+    else {
+        return (_r) => {
+            const record = _r;
+            if (type === 'text') {
+                return resolver.interface.encodeFunctionData('setText', [
+                    namehash,
+                    record.key,
+                    record.value,
+                ]);
+            }
+            else {
+                return generateSetAddr(namehash, record.key, record.value, resolver);
+            }
+        };
+    }
+}
 export const generateRecordCallArray = (namehash, records, resolver) => {
     const calls = [];
     if (records.contentHash) {
-        const contentHash = records.contentHash === '' ? '' : encodeContenthash(records.contentHash);
-        const data = resolver?.interface.encodeFunctionData('setContenthash', [namehash, contentHash]);
+        const data = generateSingleRecordCall(namehash, resolver, 'contentHash')(records.contentHash);
         data && calls.push(data);
     }
     if (records.texts && records.texts.length > 0) {
-        records.texts.forEach(({ key, value }) => {
-            const data = resolver?.interface.encodeFunctionData('setText', [
-                namehash,
-                key,
-                value,
-            ]);
-            data && calls.push(data);
-        });
+        records.texts
+            .map(generateSingleRecordCall(namehash, resolver, 'text'))
+            .forEach((call) => calls.push(call));
     }
     if (records.coinTypes && records.coinTypes.length > 0) {
-        records.coinTypes.forEach(({ key, value }) => {
-            const data = generateSetAddr(namehash, key, value, resolver);
-            data && calls.push(data);
-        });
+        records.coinTypes
+            .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+            .forEach((call) => calls.push(call));
     }
     return calls;
 };

package/dist/esm/utils/registerHelpers.js

@@ -1,6 +1,7 @@
 import { utils } from 'ethers';
 import generateFuseInput from './generateFuseInput';
 import { labelhash } from './labels';
+import { namehash } from './normalise';
 import { generateRecordCallArray } from './recordHelpers';
 export const randomSecret = () => {
     const bytes = Buffer.allocUnsafe(32);
@@ -8,11 +9,9 @@ export const randomSecret = () => {
 };
 export const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
     const label = labelhash(name.split('.')[0]);
-    const namehash = utils.namehash(name);
+    const hash = namehash(name);
     const resolverAddress = resolver.address;
-    const data = records
-        ? generateRecordCallArray(namehash, records, resolver)
-        : [];
+    const data = records ? generateRecordCallArray(hash, records, resolver) : [];
     const secret = randomSecret();
     const fuseData = fuses ? generateFuseInput(fuses) : '0';
     const commitment = _makeCommitment({

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

@@ -0,0 +1,26 @@
+import { BigNumber } from 'ethers';
+export const MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1);
+export const makeExpiry = async ({ getExpiry }, name, expiry) => {
+    if (expiry) {
+        if (expiry instanceof Date) {
+            return BigNumber.from(expiry.getTime() / 1000);
+        }
+        else if (expiry instanceof BigNumber) {
+            return expiry;
+        }
+        else {
+            return 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 BigNumber.from(expResponse.expiry.getTime() / 1000);
+        }
+        else {
+            return MAX_EXPIRY;
+        }
+    }
+};

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

@@ -0,0 +1,4 @@
+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>;
+export default _default;

package/dist/esm/utils/writeTx.js

@@ -0,0 +1 @@
+export default (signer, populate) => (tx) => populate ? tx : signer.sendTransaction(tx);