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

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

@@ -1,8 +1,6 @@
-import { BigNumberish } from '@ethersproject/bignumber/lib/bignumber';
 import type { PublicResolver } from '../generated';
-import { FuseOptions } from './fuses';
+import { CombinedFuseInput } from './fuses';
 import { RecordOptions } from './recordHelpers';
-export declare const MAX_INT_64: bigint;
 export declare type BaseRegistrationParams = {
     owner: string;
     duration: number;
@@ -10,16 +8,14 @@ export declare type BaseRegistrationParams = {
     resolverAddress?: string;
     records?: RecordOptions;
     reverseRecord?: boolean;
-    fuses?: FuseOptions;
-    wrapperExpiry?: BigNumberish;
+    fuses?: CombinedFuseInput['child'];
 };
 export declare type RegistrationParams = Omit<BaseRegistrationParams, 'resolverAddress'> & {
     name: string;
     resolver: PublicResolver;
 };
-export declare type CommitmentParams = Omit<RegistrationParams, 'secret' | 'wrapperExpiry'> & {
+export declare type CommitmentParams = Omit<RegistrationParams, 'secret'> & {
     secret?: string;
-    wrapperExpiry?: BigNumberish;
 };
 export declare type RegistrationTuple = [
     name: string,
@@ -29,31 +25,17 @@ export declare type RegistrationTuple = [
     resolver: string,
     data: string[],
     reverseRecord: boolean,
-    fuses: string,
-    wrapperExpiry: BigNumberish
-];
-export declare type CommitmentTuple = [
-    labelhash: string,
-    owner: string,
-    duration: number,
-    resolver: string,
-    data: string[],
-    secret: string,
-    reverseRecord: boolean,
-    fuses: string,
-    wrapperExpiry: BigNumberish
+    ownerControlledFuses: number
 ];
 export declare const randomSecret: () => string;
-export declare const makeCommitmentData: ({ name, owner, duration, resolver, records, reverseRecord, fuses, wrapperExpiry, secret, }: Omit<RegistrationParams, "secret" | "wrapperExpiry"> & {
+export declare const makeCommitmentData: ({ name, owner, duration, resolver, records, reverseRecord, fuses, secret, }: Omit<RegistrationParams, "secret"> & {
     secret?: string | undefined;
-    wrapperExpiry?: BigNumberish | undefined;
 } & {
     secret: string;
-}) => CommitmentTuple;
+}) => RegistrationTuple;
 export declare const makeRegistrationData: (params: RegistrationParams) => RegistrationTuple;
-export declare const _makeCommitment: (params: CommitmentTuple) => string;
+export declare const _makeCommitment: (params: RegistrationTuple) => string;
 export declare const makeCommitment: ({ secret, ...inputParams }: CommitmentParams) => {
     secret: string;
     commitment: string;
-    wrapperExpiry: BigNumberish;
 };

package/dist/types/utils/subgraph-types.d.ts

@@ -0,0 +1,284 @@
+export declare type Maybe<T> = T | null;
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export declare type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    Bytes: string;
+    BigInt: string;
+};
+export declare type Domain = {
+    __typename?: 'Domain';
+    id: Scalars['ID'];
+    name?: Maybe<Scalars['String']>;
+    labelName?: Maybe<Scalars['String']>;
+    labelhash?: Maybe<Scalars['Bytes']>;
+    parent?: Maybe<Domain>;
+    subdomains: Array<Domain>;
+    subdomainCount: Scalars['Int'];
+    resolvedAddress?: Maybe<Account>;
+    owner: Account;
+    resolver?: Maybe<Resolver>;
+    ttl?: Maybe<Scalars['BigInt']>;
+    isMigrated: Scalars['Boolean'];
+    createdAt: Scalars['BigInt'];
+    events: Array<DomainEvent>;
+    registration?: Maybe<Registration>;
+    wrappedDomain?: Maybe<WrappedDomain>;
+};
+export declare type DomainEvent = {
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+};
+export declare type Transfer = DomainEvent & {
+    __typename?: 'Transfer';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type NewOwner = DomainEvent & {
+    __typename?: 'NewOwner';
+    id: Scalars['ID'];
+    parentDomain: Domain;
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type NewResolver = DomainEvent & {
+    __typename?: 'NewResolver';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    resolver: Resolver;
+};
+export declare type NewTtl = DomainEvent & {
+    __typename?: 'NewTTL';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    ttl: Scalars['BigInt'];
+};
+export declare type WrappedTransfer = DomainEvent & {
+    __typename?: 'WrappedTransfer';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type NameWrapped = DomainEvent & {
+    __typename?: 'NameWrapped';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    name: Scalars['String'];
+    fuses: Scalars['Int'];
+    owner: Account;
+    expiryDate: Scalars['BigInt'];
+};
+export declare type NameUnwrapped = DomainEvent & {
+    __typename?: 'NameUnwrapped';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type FusesSet = DomainEvent & {
+    __typename?: 'FusesSet';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    fuses: Scalars['Int'];
+};
+export declare type ExpiryExtended = DomainEvent & {
+    __typename?: 'ExpiryExtended';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    expiryDate: Scalars['BigInt'];
+};
+export declare type Registration = {
+    __typename?: 'Registration';
+    id: Scalars['ID'];
+    domain: Domain;
+    registrationDate: Scalars['BigInt'];
+    expiryDate: Scalars['BigInt'];
+    cost?: Maybe<Scalars['BigInt']>;
+    registrant: Account;
+    labelName?: Maybe<Scalars['String']>;
+    events: Array<RegistrationEvent>;
+};
+export declare type RegistrationEvent = {
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+};
+export declare type NameRegistered = RegistrationEvent & {
+    __typename?: 'NameRegistered';
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    registrant: Account;
+    expiryDate: Scalars['BigInt'];
+};
+export declare type NameRenewed = RegistrationEvent & {
+    __typename?: 'NameRenewed';
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    expiryDate: Scalars['BigInt'];
+};
+export declare type NameTransferred = RegistrationEvent & {
+    __typename?: 'NameTransferred';
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    newOwner: Account;
+};
+export declare type WrappedDomain = {
+    __typename?: 'WrappedDomain';
+    id: Scalars['ID'];
+    domain: Domain;
+    expiryDate: Scalars['BigInt'];
+    fuses: Scalars['Int'];
+    owner: Account;
+    name?: Maybe<Scalars['String']>;
+};
+export declare type Account = {
+    __typename?: 'Account';
+    id: Scalars['ID'];
+    domains: Array<Domain>;
+    wrappedDomains?: Maybe<Array<WrappedDomain>>;
+    registrations?: Maybe<Array<Registration>>;
+};
+export declare type Resolver = {
+    __typename?: 'Resolver';
+    id: Scalars['ID'];
+    domain?: Maybe<Domain>;
+    address: Scalars['Bytes'];
+    addr?: Maybe<Account>;
+    contentHash?: Maybe<Scalars['Bytes']>;
+    texts?: Maybe<Array<Scalars['String']>>;
+    coinTypes?: Maybe<Array<Scalars['BigInt']>>;
+    events: Array<ResolverEvent>;
+};
+export declare type ResolverEvent = {
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+};
+export declare type AddrChanged = ResolverEvent & {
+    __typename?: 'AddrChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    addr: Account;
+};
+export declare type MulticoinAddrChanged = ResolverEvent & {
+    __typename?: 'MulticoinAddrChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    coinType: Scalars['BigInt'];
+    addr: Scalars['Bytes'];
+};
+export declare type NameChanged = ResolverEvent & {
+    __typename?: 'NameChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    name: Scalars['String'];
+};
+export declare type AbiChanged = ResolverEvent & {
+    __typename?: 'AbiChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    contentType: Scalars['BigInt'];
+};
+export declare type PubkeyChanged = ResolverEvent & {
+    __typename?: 'PubkeyChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    x: Scalars['Bytes'];
+    y: Scalars['Bytes'];
+};
+export declare type TextChanged = ResolverEvent & {
+    __typename?: 'TextChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    key: Scalars['String'];
+    value?: Maybe<Scalars['String']>;
+};
+export declare type ContenthashChanged = ResolverEvent & {
+    __typename?: 'ContenthashChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    hash: Scalars['Bytes'];
+};
+export declare type InterfaceChanged = ResolverEvent & {
+    __typename?: 'InterfaceChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    interfaceID: Scalars['Bytes'];
+    implementer: Scalars['Bytes'];
+};
+export declare type AuthorisationChanged = ResolverEvent & {
+    __typename?: 'AuthorisationChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Scalars['Bytes'];
+    target: Scalars['Bytes'];
+    isAuthorized: Scalars['Boolean'];
+};
+export declare type VersionChanged = ResolverEvent & {
+    __typename?: 'VersionChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    version: Scalars['BigInt'];
+};

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

@@ -5,15 +5,15 @@ declare const _default: (signer: JsonRpcSigner, populate: boolean) => ({ customD
     to?: string | undefined;
     from?: string | undefined;
     nonce?: number | undefined;
-    gasLimit?: import("@ethersproject/bignumber").BigNumber | undefined;
-    gasPrice?: import("@ethersproject/bignumber").BigNumber | undefined;
+    gasLimit?: import("ethers").BigNumber | undefined;
+    gasPrice?: import("ethers").BigNumber | undefined;
     data?: string | undefined;
-    value?: import("@ethersproject/bignumber").BigNumber | undefined;
+    value?: import("ethers").BigNumber | undefined;
     chainId?: number | undefined;
     type?: number | undefined;
     accessList?: import("@ethersproject/transactions").AccessList | undefined;
-    maxFeePerGas?: import("@ethersproject/bignumber").BigNumber | undefined;
-    maxPriorityFeePerGas?: import("@ethersproject/bignumber").BigNumber | undefined;
+    maxFeePerGas?: import("ethers").BigNumber | undefined;
+    maxPriorityFeePerGas?: import("ethers").BigNumber | undefined;
     ccipReadEnabled?: boolean | undefined;
 } | Promise<import("@ethersproject/abstract-provider").TransactionResponse | (import("@ethersproject/abstract-provider").TransactionResponse & {
     customData: CustomData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.40",
+  "version": "3.0.0-alpha.42",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -59,17 +59,18 @@
     "@ensdomains/content-hash": "^2.5.7",
     "@ensdomains/dnsprovejs": "^0.4.1",
     "@ensdomains/dnssecoraclejs": "^0.2.7",
+    "cbor": "^8.1.0",
     "dns-packet": "^5.3.1",
     "graphql": "^16.3.0",
     "graphql-request": "next",
     "idna-uts46-hx": "3.4.0",
+    "pako": "^2.1.0",
     "traverse": "^0.6.6"
   },
   "devDependencies": {
-    "ethers": "^5.7.2",
     "@ensdomains/buffer": "^0.0.13",
-    "@ensdomains/ens-contracts": "^0.0.15",
-    "@ensdomains/ens-test-env": "0.3.6",
+    "@ensdomains/ens-contracts": "^0.0.16",
+    "@ensdomains/ens-test-env": "0.3.7",
     "@ethersproject/abi": "^5.6.4",
     "@ethersproject/abstract-provider": "^5.7.0",
     "@ethersproject/abstract-signer": "^5.7.0",
@@ -91,10 +92,12 @@
     "@typechain/ethers-v5": "^10.1.0",
     "@types/bn.js": "^5.1.0",
     "@types/jest": "^27.4.1",
+    "@types/pako": "^2.0.0",
     "@types/traverse": "^0.6.32",
     "dotenv": "^16.0.0",
     "esbuild": "^0.15.6",
     "eslint-plugin-jest": "^27.0.1",
+    "ethers": "^5.7.2",
     "ganache": "^7.4.0",
     "glob": "^8.0.3",
     "hardhat": "2.10.2",
@@ -130,7 +133,7 @@
   },
   "scripts": {
     "tenv": "ens-test-env -a",
-    "denv": "pnpm tenv start -ns -nb --extra-time 11368000",
+    "denv": "pnpm tenv start -ns -nb --extra-time 11368000 --verbosity 1",
     "generate-types": "ts-node scripts/runTypechain.ts",
     "generate-abis": "hardhat export-abi",
     "start": "ts-node --files src/index.test.ts",

package/src/@types/pako.d.ts

@@ -0,0 +1,188 @@
+/* eslint-disable max-classes-per-file */
+// Type definitions for pako 2.0
+// Project: https://github.com/nodeca/pako
+// Definitions by: Caleb Eggensperger <https://github.com/calebegg>
+//                 Muhammet Öztürk <https://github.com/hlthi>
+//                 Thibault Poisson <https://github.com/OrIOg>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+enum constants {
+  // FlushValues
+  Z_NO_FLUSH = 0,
+  Z_PARTIAL_FLUSH = 1,
+  Z_SYNC_FLUSH = 2,
+  Z_FULL_FLUSH = 3,
+  Z_FINISH = 4,
+  Z_BLOCK = 5,
+  Z_TREES = 6,
+  // StrategyValues
+  Z_FILTERED = 1,
+  Z_HUFFMAN_ONLY = 2,
+  Z_RLE = 3,
+  Z_FIXED = 4,
+  Z_DEFAULT_STRATEGY = 0,
+  // ReturnCodes
+  Z_OK = 0,
+  Z_STREAM_END = 1,
+  Z_NEED_DICT = 2,
+  Z_ERRNO = -1,
+  Z_STREAM_ERROR = -2,
+  Z_DATA_ERROR = -3,
+  Z_BUF_ERROR = -5,
+}
+
+type FlushValues =
+  | constants.Z_NO_FLUSH
+  | constants.Z_PARTIAL_FLUSH
+  | constants.Z_SYNC_FLUSH
+  | constants.Z_FINISH
+  | constants.Z_BLOCK
+  | constants.Z_TREES
+
+type StrategyValues =
+  | constants.Z_FILTERED
+  | constants.Z_HUFFMAN_ONLY
+  | constants.Z_RLE
+  | constants.Z_FIXED
+  | constants.Z_DEFAULT_STRATEGY
+
+type ReturnCodes =
+  | constants.Z_OK
+  | constants.Z_STREAM_END
+  | constants.Z_NEED_DICT
+  | constants.Z_ERRNO
+  | constants.Z_STREAM_ERROR
+  | constants.Z_DATA_ERROR
+  | constants.Z_BUF_ERROR
+  | constants.Z_DEFAULT_STRATEGY
+
+interface DeflateOptions {
+  level?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined
+  windowBits?: number | undefined
+  memLevel?: number | undefined
+  strategy?: StrategyValues | undefined
+  dictionary?: any
+  raw?: boolean | undefined
+  chunkSize?: number | undefined
+  gzip?: boolean | undefined
+  header?: Header | undefined
+}
+
+interface DeflateFunctionOptions {
+  level?: -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined
+  windowBits?: number | undefined
+  memLevel?: number | undefined
+  strategy?: StrategyValues | undefined
+  dictionary?: any
+  raw?: boolean | undefined
+}
+
+interface InflateOptions {
+  windowBits?: number | undefined
+  dictionary?: any
+  raw?: boolean | undefined
+  to?: 'string' | undefined
+  chunkSize?: number | undefined
+}
+
+interface InflateFunctionOptions {
+  windowBits?: number | undefined
+  raw?: boolean | undefined
+  to?: 'string' | undefined
+}
+
+interface Header {
+  text?: boolean | undefined
+  time?: number | undefined
+  os?: number | undefined
+  extra?: number[] | undefined
+  name?: string | undefined
+  comment?: string | undefined
+  hcrc?: boolean | undefined
+}
+
+type Data = Uint8Array | ArrayBuffer
+
+declare module 'pako/dist/pako_inflate.min.js' {
+  /**
+   * Decompress data with inflate/ungzip and options. Autodetect format via wrapper header
+   * by default. That's why we don't provide separate ungzip method.
+   */
+  function inflate(
+    data: Data,
+    options: InflateFunctionOptions & { to: 'string' },
+  ): string
+  function inflate(data: Data, options?: InflateFunctionOptions): Uint8Array
+
+  /**
+   * The same as inflate, but creates raw data, without wrapper (header and adler32 crc).
+   */
+  function inflateRaw(
+    data: Data,
+    options: InflateFunctionOptions & { to: 'string' },
+  ): string
+  function inflateRaw(data: Data, options?: InflateFunctionOptions): Uint8Array
+
+  /**
+   * Just shortcut to inflate, because it autodetects format by header.content. Done for convenience.
+   */
+  function ungzip(
+    data: Data,
+    options: InflateFunctionOptions & { to: 'string' },
+  ): string
+  function ungzip(data: Data, options?: InflateFunctionOptions): Uint8Array
+
+  // https://github.com/nodeca/pako/blob/893381abcafa10fa2081ce60dae7d4d8e873a658/lib/inflate.js
+  class Inflate {
+    constructor(options?: InflateOptions)
+    header?: Header | undefined
+
+    err: ReturnCodes
+
+    msg: string
+
+    result: Uint8Array | string
+    onData(chunk: Data): void
+    onEnd(status: number): void
+    push(data: Data, mode?: FlushValues | boolean): boolean
+  }
+}
+
+declare module 'pako/dist/pako_deflate.min.js' {
+  /**
+   * Compress data with deflate algorithm and options.
+   */
+  function deflate(
+    data: Data | string,
+    options?: DeflateFunctionOptions,
+  ): Uint8Array
+
+  /**
+   * The same as deflate, but creates raw data, without wrapper (header and adler32 crc).
+   */
+  function deflateRaw(
+    data: Data | string,
+    options?: DeflateFunctionOptions,
+  ): Uint8Array
+
+  /**
+   * The same as deflate, but create gzip wrapper instead of deflate one.
+   */
+  function gzip(
+    data: Data | string,
+    options?: DeflateFunctionOptions,
+  ): Uint8Array
+
+  class Deflate {
+    constructor(options?: DeflateOptions)
+    err: ReturnCodes
+
+    msg: string
+
+    result: Uint8Array
+    onData(chunk: Data): void
+    onEnd(status: number): void
+    push(data: Data | string, mode?: FlushValues | boolean): boolean
+  }
+}

package/src/contracts/bulkRenewal.ts

@@ -1,6 +1,6 @@
 import type { JsonRpcProvider } from '@ethersproject/providers'
 import { BulkRenewal__factory } from '../generated/factories/BulkRenewal__factory'
 
-// Use a higher-order function to overide the address that is passed in from getContractAddress()
+// Use a higher-order function to override the address that is passed in from getContractAddress()
 export default (provider: JsonRpcProvider, address: string) =>
   BulkRenewal__factory.connect(address, provider)

package/src/contracts/getContractAddress.ts

@@ -20,19 +20,19 @@ const addresses: Record<
     '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
     '3': '0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8',
     '4': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-    '5': '0x9C51161bA2FB02Cc0a403332B607117685f34831',
+    '5': '0xb7A1f9e633fdeaAa2ec44bE00a61a7Db9a733D70',
   },
   Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
   NameWrapper: {
     '1': '0x0000000000000000000000000000000000000000',
     '3': '0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C',
     '4': '0x0000000000000000000000000000000000000000',
-    '5': '0x582224b8d4534F4749EFA4f22eF7241E0C56D4B8',
+    '5': '0xEe1F756aCde7E81B2D8cC6aB3c8A1E2cE6db0F39',
   },
   PublicResolver: {
     '1': '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
     '3': '0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837',
-    '5': '0xE264d5bb84bA3b8061ADC38D3D76e6674aB91852',
+    '5': '0x2800Ec5BAB9CE9226d19E0ad5BC607e3cfC4347E',
   },
   ENSRegistry: {
     '1': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
@@ -43,7 +43,7 @@ const addresses: Record<
   ReverseRegistrar: {
     '1': '0x084b1c3C81545d370f3634392De611CaaBFf8148',
     '3': '0x806246b52f8cB61655d3038c58D2f63Aa55d4edE',
-    '5': '0xD5610A08E370051a01fdfe4bB3ddf5270af1aA48',
+    '5': '0x9a879320A9F7ad2BBb02063d67baF5551D6BD8B0',
   },
   UniversalResolver: {
     '1': '0x74E20Bd2A1fE0cdbe45b9A1d89cb7e0a45b36376',

package/src/functions/commitName.test.ts

@@ -31,7 +31,6 @@ describe('commitName', () => {
     expect(popTx).toBeTruthy()
     expect(customData).toHaveProperty('secret')
     expect(customData).toHaveProperty('commitment')
-    expect(customData).toHaveProperty('wrapperExpiry')
 
     const tx = await provider.getSigner().sendTransaction(popTx)
     await tx.wait()
@@ -47,11 +46,9 @@ describe('commitName', () => {
       owner: accounts[1],
       addressOrIndex: accounts[1],
       secret,
-      wrapperExpiry: 100000,
     })
     await tx.wait()
     expect(tx.customData).toBeTruthy()
-    expect(tx.customData!.wrapperExpiry).toBe(100000)
     expect(tx.customData!.secret).toBe(secret)
 
     const controller = await ensInstance.contracts!.getEthRegistrarController()!

package/src/functions/commitName.ts

@@ -22,7 +22,7 @@ export default async function (
     undefined,
     resolverAddress,
   )
-  const { secret, commitment, wrapperExpiry } = makeCommitment({
+  const { secret, commitment } = makeCommitment({
     name,
     resolver,
     ...params,
@@ -33,7 +33,6 @@ export default async function (
     customData: {
       secret,
       commitment,
-      wrapperExpiry,
     },
   }
 }