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

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

@@ -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/cjs/index.js

@@ -31,6 +31,7 @@ const contracts_1 = __importDefault(require("./contracts"));
 const getContractAddress_1 = require("./contracts/getContractAddress");
 const GqlManager_1 = __importDefault(require("./GqlManager"));
 const singleCall_1 = __importDefault(require("./utils/singleCall"));
+const writeTx_1 = __importDefault(require("./utils/writeTx"));
 const graphURIEndpoints = {
     1: 'https://api.thegraph.com/subgraphs/name/ensdomains/ens',
     3: 'https://api.thegraph.com/subgraphs/name/ensdomains/ensropsten',
@@ -89,15 +90,30 @@ class ENS {
             await thisRef.checkInitialProvider();
             // import the module dynamically
             const mod = await Promise.resolve().then(() => __importStar(require(
-            /* 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((0, writeTx_1.default)(signer, populate));
+                }
                 // return the function with the dependencies forwarded
                 return func(dependenciesToForward, ...args);
             }
@@ -114,6 +130,9 @@ 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;
     };
     /**
@@ -124,6 +143,14 @@ class ENS {
      * @returns {OmitFirstArg} - The generated wrapped function
      */
     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
+     */
+    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
@@ -166,6 +193,7 @@ class ENS {
         'gqlInstance',
         'getName',
         'resolverMulticallWrapper',
+        'multicallWrapper',
         '_getAddr',
         '_getContentHash',
         '_getText',
@@ -177,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');
@@ -193,31 +219,28 @@ class ENS {
     universalWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'universalWrapper');
     resolverMulticallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'resolverMulticallWrapper');
     multicallWrapper = this.generateRawFunction('initialGetters', ['contracts'], 'multicallWrapper');
-    setName = this.generateFunction('setName', [
+    setName = this.generateWriteFunction('setName', [
         'contracts',
-        'provider',
     ]);
-    setRecords = this.generateFunction('setRecords', [
+    setRecords = this.generateWriteFunction('setRecords', ['contracts', 'provider', 'getResolver']);
+    setRecord = this.generateWriteFunction('setRecord', [
         'contracts',
         'provider',
         'getResolver',
     ]);
-    setResolver = this.generateFunction('setResolver', ['contracts', 'provider']);
-    transferName = this.generateFunction('transferName', ['contracts', 'provider']);
-    wrapName = this.generateFunction('wrapName', [
+    setResolver = this.generateWriteFunction('setResolver', ['contracts']);
+    transferName = this.generateWriteFunction('transferName', ['contracts']);
+    wrapName = this.generateWriteFunction('wrapName', [
         'contracts',
-        'provider',
+        'getExpiry',
     ]);
-    unwrapName = this.generateFunction('unwrapName', [
+    unwrapName = this.generateWriteFunction('unwrapName', ['contracts']);
+    burnFuses = this.generateWriteFunction('burnFuses', [
         'contracts',
-        'provider',
-    ]);
-    burnFuses = this.generateFunction('burnFuses', [
-        'contracts',
-        'provider',
     ]);
-    createSubname = this.generateFunction('createSubname', ['contracts', 'provider']);
-    deleteSubname = this.generateFunction('deleteSubname', ['contracts', 'provider', 'transferSubname']);
-    transferSubname = this.generateFunction('transferSubname', ['contracts', 'provider']);
+    createSubname = this.generateWriteFunction('createSubname', ['contracts', 'getExpiry']);
+    deleteSubname = this.generateWriteFunction('deleteSubname', ['transferSubname']);
+    transferSubname = this.generateWriteFunction('transferSubname', ['contracts', 'getExpiry']);
+    getDNSOwner = this.generateFunction('getDNSOwner', []);
 }
 exports.ENS = ENS;

package/dist/cjs/utils/labels.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkLocalStorageSize = exports.truncateUndecryptedName = exports.decryptName = exports.checkIsDecrypted = exports.parseName = exports.encodeLabel = exports.checkLabel = exports.saveName = exports.saveLabel = exports.isEncodedLabelhash = exports.encodeLabelhash = exports.decodeLabelhash = exports.keccakFromString = exports.labelhash = void 0;
 const utils_1 = require("ethers/lib/utils");
 const format_1 = require("./format");
+const hasLocalStorage = typeof localStorage !== 'undefined';
 const labelhash = (input) => (0, utils_1.solidityKeccak256)(['string'], [input]);
 exports.labelhash = labelhash;
 const keccakFromString = (input) => (0, exports.labelhash)(input);
@@ -14,7 +15,7 @@ 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)}`;
 }
 exports.decodeLabelhash = decodeLabelhash;
 function encodeLabelhash(hash) {
@@ -32,12 +33,12 @@ function isEncodedLabelhash(hash) {
 }
 exports.isEncodedLabelhash = isEncodedLabelhash;
 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({
@@ -97,7 +98,7 @@ exports.decryptName = decryptName;
 const truncateUndecryptedName = (name) => (0, format_1.truncateFormat)(name);
 exports.truncateUndecryptedName = truncateUndecryptedName;
 function checkLocalStorageSize() {
-    if (!localStorage)
+    if (!hasLocalStorage)
         return 'Empty (0 KB)';
     let allStrings = '';
     for (const key in window.localStorage) {

package/dist/cjs/utils/makeHashIndexes.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeNamehashIndexes = exports.makeOtherIndexes = void 0;
-const ethers_1 = require("ethers");
+const normalise_1 = require("./normalise");
 const makeOtherIndexes = (data, findStr) => Array.from(data.matchAll(findStr)).map((x) => x.index / 2 - 1);
 exports.makeOtherIndexes = makeOtherIndexes;
-const makeNamehashIndexes = (data, name) => Array.from(data.matchAll(ethers_1.ethers.utils.namehash(name).substring(2))).map((x) => x.index / 2 - 1);
+const makeNamehashIndexes = (data, name) => Array.from(data.matchAll((0, normalise_1.namehash)(name).substring(2))).map((x) => x.index / 2 - 1);
 exports.makeNamehashIndexes = makeNamehashIndexes;

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

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

package/dist/cjs/utils/normalise.js

@@ -3,7 +3,33 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalise = void 0;
+exports.namehash = exports.normalise = void 0;
+const utils_1 = require("ethers/lib/utils");
 const uts46bundle_js_1 = __importDefault(require("idna-uts46-hx/uts46bundle.js"));
+const labels_1 = require("./labels");
+const zeros = new Uint8Array(32);
+zeros.fill(0);
 const normalise = (name) => name ? uts46bundle_js_1.default.toUnicode(name, { useStd3ASCII: true }) : name;
 exports.normalise = normalise;
+const namehash = (name) => {
+    let result = zeros;
+    if (name) {
+        const labels = name.split('.');
+        for (var i = labels.length - 1; i >= 0; i--) {
+            let labelSha;
+            if ((0, labels_1.isEncodedLabelhash)(labels[i])) {
+                labelSha = (0, labels_1.decodeLabelhash)(labels[i]);
+            }
+            else {
+                const normalised = (0, exports.normalise)(labels[i]);
+                labelSha = (0, utils_1.keccak256)((0, utils_1.toUtf8Bytes)(normalised));
+            }
+            result = (0, utils_1.keccak256)((0, utils_1.concat)([result, labelSha]));
+        }
+    }
+    else {
+        result = (0, utils_1.hexlify)(zeros);
+    }
+    return result;
+};
+exports.namehash = namehash;

package/dist/cjs/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/cjs/utils/recordHelpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRecordCallArray = exports.generateSetAddr = void 0;
+exports.generateRecordCallArray = exports.generateSingleRecordCall = exports.generateSetAddr = void 0;
 const address_encoder_1 = require("@ensdomains/address-encoder");
 const contentHash_1 = require("./contentHash");
 const generateSetAddr = (namehash, coinType, address, resolver) => {
@@ -16,28 +16,55 @@ const generateSetAddr = (namehash, coinType, address, resolver) => {
     return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
 };
 exports.generateSetAddr = generateSetAddr;
+function generateSingleRecordCall(namehash, resolver, type) {
+    if (type === 'contentHash') {
+        return (_r) => {
+            const record = _r;
+            let _contentHash = '';
+            if (record !== _contentHash) {
+                const encoded = (0, contentHash_1.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 (0, exports.generateSetAddr)(namehash, record.key, record.value, resolver);
+            }
+        };
+    }
+}
+exports.generateSingleRecordCall = generateSingleRecordCall;
 const generateRecordCallArray = (namehash, records, resolver) => {
     const calls = [];
     if (records.contentHash) {
-        const contentHash = records.contentHash === '' ? '' : (0, contentHash_1.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 = (0, exports.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/cjs/utils/registerHelpers.js

@@ -7,6 +7,7 @@ exports._makeCommitment = exports.makeCommitment = exports.randomSecret = void 0
 const ethers_1 = require("ethers");
 const generateFuseInput_1 = __importDefault(require("./generateFuseInput"));
 const labels_1 = require("./labels");
+const normalise_1 = require("./normalise");
 const recordHelpers_1 = require("./recordHelpers");
 const randomSecret = () => {
     const bytes = Buffer.allocUnsafe(32);
@@ -15,11 +16,9 @@ const randomSecret = () => {
 exports.randomSecret = randomSecret;
 const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
     const label = (0, labels_1.labelhash)(name.split('.')[0]);
-    const namehash = ethers_1.utils.namehash(name);
+    const hash = (0, normalise_1.namehash)(name);
     const resolverAddress = resolver.address;
-    const data = records
-        ? (0, recordHelpers_1.generateRecordCallArray)(namehash, records, resolver)
-        : [];
+    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)({

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>;