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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.11",
+  "version": "3.0.0-alpha.14",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "types": "./dist/cjs/index.d.ts",
@@ -22,26 +22,8 @@
   "repository": "git@github.com:ensdomains/ensjs-v3.git",
   "author": "TateB <yo@taytems.xyz>",
   "license": "MIT",
-  "scripts": {
-    "env": "yarn ens-test-env",
-    "generate-types": "ts-node scripts/runTypechain.ts",
-    "generate-abis": "hardhat export-abi",
-    "start": "ts-node --files src/index.test.ts",
-    "test": "jest --run-in-band",
-    "test:watch": "jest --watch --run-in-band",
-    "test:specific": "ts-node --files ",
-    "clean": "rm -rf ./dist ./README.md ./LICENSE",
-    "build:esm": "tsc --project tsconfig.esm.json",
-    "build:cjs": "tsc --project tsconfig.cjs.json",
-    "build": "yarn clean && yarn build:esm && yarn build:cjs",
-    "prepublish": "yarn build && cp ../../{README.md,LICENSE} ./",
-    "remove-stableVersion": "ex -c '%s/,\\n\\s\\+\"stableVersion\".*\"//g' -cwq ./package.json",
-    "version:create": "yarn remove-stableVersion && yarn version",
-    "enode": "ganache --wallet.mnemonic=\"test test test test test test test test test test test junk\" --chain.chainId 1337 --chain.networkId 1337 --chain.time 1659500634000"
-  },
-  "packageManager": "yarn@3.2.0",
   "dependencies": {
-    "@ensdomains/address-encoder": "^0.2.16",
+    "@ensdomains/address-encoder": "0.2.16",
     "@ensdomains/content-hash": "^2.5.7",
     "dns-packet": "^5.3.1",
     "ethers": "^5.6.1",
@@ -53,7 +35,7 @@
   "devDependencies": {
     "@ensdomains/buffer": "^0.0.13",
     "@ensdomains/ens-contracts": "^0.0.12",
-    "@ensdomains/ens-test-env": "0.1.5",
+    "@ensdomains/ens-test-env": "0.2.2",
     "@ethersproject/abi": "^5.6.0",
     "@ethersproject/providers": "^5.6.2",
     "@nomiclabs/hardhat-ethers": "npm:hardhat-deploy-ethers",
@@ -85,5 +67,20 @@
   "peerDependencies": {
     "ethers": "*"
   },
-  "stableVersion": "3.0.0-alpha.10"
+  "scripts": {
+    "tenv": "ens-test-env -a",
+    "generate-types": "ts-node scripts/runTypechain.ts",
+    "generate-abis": "hardhat export-abi",
+    "start": "ts-node --files src/index.test.ts",
+    "test": "jest --run-in-band",
+    "test:watch": "jest --watch --run-in-band",
+    "test:specific": "ts-node --files ",
+    "clean": "rm -rf ./dist ./README.md ./LICENSE",
+    "build:esm": "tsc --project tsconfig.esm.json",
+    "build:cjs": "tsc --project tsconfig.cjs.json",
+    "build": "pnpm clean && pnpm build:esm && pnpm build:cjs",
+    "prepublish": "pnpm build && cp ../../README.md ../../LICENSE ./",
+    "enode": "ganache --wallet.mnemonic=\"test test test test test test test test test test test junk\" --chain.chainId 1337 --chain.networkId 1337 --chain.time 1659500634000",
+    "ver": "pnpm version --no-workspaces-update"
+  }
 }

package/src/functions/burnFuses.test.ts

@@ -21,20 +21,128 @@ describe('burnFuses', () => {
   beforeEach(async () => {
     await revert()
   })
-  it('should return a burnFuses transaction and succeed', async () => {
-    const tx = await ENSInstance.burnFuses('wrapped.eth', {
-      fusesToBurn: {
-        cannotUnwrap: true,
-        cannotCreateSubdomain: true,
-        cannotSetTtl: true,
-      },
-      addressOrIndex: accounts[1],
-    })
-    expect(tx).toBeTruthy()
-    await tx.wait()
-
-    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
-    expect(fuses).toBe(113)
+  describe('Array', () => {
+    it('should return a burnFuses transaction from a named fuse array and succeed', async () => {
+      const tx = await ENSInstance.burnFuses('wrapped.eth', {
+        namedFusesToBurn: [
+          'CANNOT_UNWRAP',
+          'CANNOT_CREATE_SUBDOMAIN',
+          'CANNOT_SET_TTL',
+        ],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+      const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
+      expect(fuses).toBe(113)
+    })
+    it('should return a burnFuses transaction from an unnamed fuse array and succeed', async () => {
+      const tx0 = await ENSInstance.burnFuses('wrapped.eth', {
+        namedFusesToBurn: ['CANNOT_UNWRAP'],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx0).toBeTruthy()
+      await tx0.wait()
+
+      const tx = await ENSInstance.burnFuses('wrapped.eth', {
+        unnamedFusesToBurn: [128, 256, 512],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+      const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
+      expect(fuses).toBe(961)
+    })
+    it('should return a burnFuses transaction from both an unnamed and named fuse array and succeed', async () => {
+      const tx = await ENSInstance.burnFuses('wrapped.eth', {
+        namedFusesToBurn: [
+          'CANNOT_UNWRAP',
+          'CANNOT_CREATE_SUBDOMAIN',
+          'CANNOT_SET_TTL',
+        ],
+        unnamedFusesToBurn: [128, 256, 512],
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+      const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
+      expect(fuses).toBe(1009)
+    })
+    it('should throw an error when trying to burn a named fuse in an unnamed fuse array', async () => {
+      try {
+        await ENSInstance.burnFuses('wrapped.eth', {
+          unnamedFusesToBurn: [64] as any,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          '64 is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.',
+        )
+      }
+    })
+    it('should throw an error when trying to burn an unnamed fuse in a named fuse array', async () => {
+      try {
+        await ENSInstance.burnFuses('wrapped.eth', {
+          namedFusesToBurn: ['COOL_SWAG_FUSE'] as any,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe('COOL_SWAG_FUSE is not a valid named fuse.')
+      }
+    })
+  })
+  describe('Number', () => {
+    it('should return a burnFuses transaction from a number and succeed', async () => {
+      const tx = await ENSInstance.burnFuses('wrapped.eth', {
+        fuseNumberToBurn: 49,
+        addressOrIndex: accounts[1],
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+
+      const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+      const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
+      expect(fuses).toBe(113)
+    })
+    it('should throw an error if the number is too high', async () => {
+      try {
+        await ENSInstance.burnFuses('wrapped.eth', {
+          fuseNumberToBurn: 4294967297,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          'Fuse number must be limited to uint32, 4294967297 was too high.',
+        )
+      }
+    })
+    it('should throw an error if the number is too low', async () => {
+      try {
+        await ENSInstance.burnFuses('wrapped.eth', {
+          fuseNumberToBurn: -1,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe(
+          'Fuse number must be limited to uint32, -1 was too low.',
+        )
+      }
+    })
+    it('should throw an error if the number is not an integer', async () => {
+      try {
+        await ENSInstance.burnFuses('wrapped.eth', {
+          fuseNumberToBurn: 7.5,
+        })
+        expect(false).toBeTruthy()
+      } catch (e: any) {
+        expect(e.message).toBe('Fuse number must be an integer, 7.5 was not.')
+      }
+    })
   })
 })

package/src/functions/burnFuses.ts

@@ -1,21 +1,112 @@
 import { ENSArgs } from '..'
-import { FuseOptions } from '../@types/FuseOptions'
-import generateFuseInput from '../utils/generateFuseInput'
+import { fuseEnum, unnamedFuses } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
 
-export default async function (
+type FuseObj = typeof fuseEnum
+type UnnamedFuseType = typeof unnamedFuses
+type Fuse = keyof FuseObj
+type NamedFuseValues = FuseObj[Fuse]
+type UnnamedFuseValues = UnnamedFuseType[number]
+
+// We need this type so that the following type isn't infinite. This type limits the max length of the fuse array to 7.
+type FuseArrayPossibilities =
+  | [Fuse]
+  | [Fuse, Fuse]
+  | [Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]
+  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]
+
+/**
+ * This type creates a type error if there are any duplicate fuses.
+ * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
+ *
+ * @template A The array to check for duplicates.
+ * @template B The union of all checked existing types.
+ */
+// CLAUSE A: This extension unwraps the type as a fuse tuple.
+type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities
+  ? // CLAUSE A > TRUE: CLAUSE B: Pick out the first item in the current array, separating the current item from the rest.
+    A extends [infer Head, ...infer Tail]
+    ? // CLAUSE B > TRUE: CLAUSE C: Check if the current item is a duplicate based on the input union.
+      Head extends B
+      ? // CLAUSE C > TRUE: Duplicate found, return an empty array to throw a type error.
+        []
+      : // CLAUSE C > FALSE: Return a new array to continue the recursion, adds the current item type to the union.
+        [Head, ...FusesWithoutDuplicates<Tail, Head | B>]
+    : // CLAUSE B > FALSE: Return the input array as there is no more array elements to check.
+      A
+  : // CLAUSE A > FALSE: Return an empty array as it isn't a fuse tuple.
+    []
+
+type FusePropsNamedArray<A extends FuseArrayPossibilities> = {
+  namedFusesToBurn: FusesWithoutDuplicates<A>
+}
+
+type FusePropsUnnamedArray = {
+  unnamedFusesToBurn: UnnamedFuseValues[]
+}
+
+type FusePropsNumber = {
+  fuseNumberToBurn: number
+}
+
+type FuseProps<A extends FuseArrayPossibilities> =
+  | (Partial<FusePropsNamedArray<A>> & FusePropsUnnamedArray)
+  | (FusePropsNamedArray<A> & Partial<FusePropsUnnamedArray>)
+  | FusePropsNumber
+
+export default async function <A extends FuseArrayPossibilities>(
   { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
   name: string,
-  {
-    fusesToBurn,
-  }: {
-    fusesToBurn: FuseOptions
-  },
+  props: FuseProps<A>,
 ) {
+  const isNumber = 'fuseNumberToBurn' in props
+  const hasNamedArray = 'namedFusesToBurn' in props
+  const hasUnnamedArray = 'unnamedFusesToBurn' in props
+
+  let encodedFuses: number = 0
+
+  if (isNumber) {
+    if (props.fuseNumberToBurn > 2 ** 32 || props.fuseNumberToBurn < 1) {
+      throw new Error(
+        `Fuse number must be limited to uint32, ${
+          props.fuseNumberToBurn
+        } was too ${props.fuseNumberToBurn < 1 ? 'low' : 'high'}.`,
+      )
+    } else if (props.fuseNumberToBurn % 1 !== 0) {
+      throw new Error(
+        `Fuse number must be an integer, ${props.fuseNumberToBurn} was not.`,
+      )
+    }
+    encodedFuses = props.fuseNumberToBurn
+  } else {
+    if (!hasNamedArray && !hasUnnamedArray) {
+      throw new Error('Please provide fuses to burn')
+    }
+    if (hasNamedArray) {
+      for (const fuse of props.namedFusesToBurn!) {
+        if (!(fuse in fuseEnum)) {
+          throw new Error(`${fuse} is not a valid named fuse.`)
+        }
+        encodedFuses |= fuseEnum[fuse]
+      }
+    }
+    if (hasUnnamedArray) {
+      for (const fuse of props.unnamedFusesToBurn!) {
+        if (!unnamedFuses.includes(fuse)) {
+          throw new Error(
+            `${fuse} is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.`,
+          )
+        }
+        encodedFuses |= fuse
+      }
+    }
+  }
+
   const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
   const hash = namehash(name)
 
-  const encodedFuses = generateFuseInput(fusesToBurn)
-
   return nameWrapper.populateTransaction.setFuses(hash, encodedFuses)
 }

package/src/functions/commitName.test.ts

@@ -0,0 +1,61 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { randomSecret } from '../utils/registerHelpers'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('commitName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a populated commit transaction with extra data and succeed', async () => {
+    const { customData, ...popTx } =
+      await ENSInstance.commitName.populateTransaction('commitment.eth', {
+        duration: 31536000,
+        owner: accounts[1],
+        addressOrIndex: accounts[1],
+      })
+    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()
+
+    const controller = await ENSInstance.contracts!.getEthRegistrarController()!
+    const commitment = await controller.commitments(customData!.commitment)
+    expect(commitment).toBeTruthy()
+  })
+  it('should return a customised commmit transaction and succeed', async () => {
+    const secret = randomSecret()
+    const tx = await ENSInstance.commitName('commitment.eth', {
+      duration: 31536000,
+      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()!
+    const commitment = await controller.commitments(tx.customData!.commitment)
+    expect(commitment).toBeTruthy()
+  })
+})

package/src/functions/commitName.ts

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

package/src/functions/getFuses.test.ts

@@ -1,4 +1,4 @@
-import { ethers } from 'ethers'
+import { BigNumber, ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 
@@ -9,6 +9,22 @@ let provider: ethers.providers.JsonRpcProvider
 let accounts: string[]
 let withWrappedSnapshot: any
 
+const unwrappedNameDefault = {
+  expiryDate: new Date(0).toString(),
+  fuseObj: {
+    CANNOT_BURN_FUSES: false,
+    CANNOT_CREATE_SUBDOMAIN: false,
+    CANNOT_SET_RESOLVER: false,
+    CANNOT_SET_TTL: false,
+    CANNOT_TRANSFER: false,
+    CANNOT_UNWRAP: false,
+    PARENT_CANNOT_CONTROL: false,
+    canDoEverything: true,
+  },
+  owner: '0x0000000000000000000000000000000000000000',
+  rawFuses: BigNumber.from(0),
+}
+
 beforeAll(async () => {
   ;({ ENSInstance, revert, provider, createSnapshot } = await setup())
   accounts = await provider.listAccounts()
@@ -26,9 +42,11 @@ afterAll(async () => {
 })
 
 describe('getFuses', () => {
-  it('should return null for an unwrapped name', async () => {
+  it('should return default data for an unwrapped name', async () => {
     const result = await ENSInstance.getFuses('with-profile.eth')
-    expect(result).toBeUndefined()
+    expect({ ...result, expiryDate: result?.expiryDate.toString() }).toEqual(
+      unwrappedNameDefault,
+    )
   })
   it('should return with canDoEverything set to true for a name with no fuses burned', async () => {
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
@@ -47,11 +65,11 @@ describe('getFuses', () => {
   })
   it('should return with other correct fuses', async () => {
     const tx = await ENSInstance.burnFuses('wrapped.eth', {
-      fusesToBurn: {
-        cannotUnwrap: true,
-        cannotSetTtl: true,
-        cannotCreateSubdomain: true,
-      },
+      namedFusesToBurn: [
+        'CANNOT_UNWRAP',
+        'CANNOT_CREATE_SUBDOMAIN',
+        'CANNOT_SET_TTL',
+      ],
       addressOrIndex: 1,
     })
     await tx.wait()
@@ -60,13 +78,13 @@ describe('getFuses', () => {
     expect(result).toBeTruthy()
     if (result) {
       expect(result.fuseObj).toMatchObject({
-        cannotUnwrap: true,
-        cannotBurnFuses: false,
-        cannotTransfer: false,
-        cannotSetResolver: false,
-        cannotSetTtl: true,
-        cannotCreateSubdomain: true,
-        parentCannotControl: true,
+        CANNOT_UNWRAP: true,
+        CANNOT_BURN_FUSES: false,
+        CANNOT_TRANSFER: false,
+        CANNOT_SET_RESOLVER: false,
+        CANNOT_SET_TTL: true,
+        CANNOT_CREATE_SUBDOMAIN: true,
+        PARENT_CANNOT_CONTROL: true,
         canDoEverything: false,
       })
       expect(result.rawFuses.toHexString()).toBe('0x71')

package/src/functions/getFuses.ts

@@ -1,48 +1,34 @@
 import { BigNumber } from 'ethers'
 import { ENSArgs } from '..'
-import { testable as fuseEnums } from '../utils/fuses'
+import { fuseEnum } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
 
-const NameSafety = [
-  'Safe',
-  'RegistrantNotWrapped',
-  'ControllerNotWrapped',
-  'SubdomainReplacementAllowed',
-  'Expired',
-]
-
 const raw = async ({ contracts }: ENSArgs<'contracts'>, name: string) => {
   const nameWrapper = await contracts?.getNameWrapper()!
   return {
     to: nameWrapper.address,
-    data: nameWrapper.interface.encodeFunctionData('getFuses', [
-      namehash(name),
-    ]),
+    data: nameWrapper.interface.encodeFunctionData('getData', [namehash(name)]),
   }
 }
 
 const decode = async (
   { contracts }: ENSArgs<'contracts'>,
   data: string,
-  name: string,
 ) => {
   const nameWrapper = await contracts?.getNameWrapper()!
   try {
-    const [_fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
-      'getFuses',
-      data,
-    )
+    const {
+      owner,
+      fuses: _fuses,
+      expiry,
+    } = nameWrapper.interface.decodeFunctionResult('getData', data)
 
     const fuses = BigNumber.from(_fuses)
 
     const fuseObj = Object.fromEntries(
-      Object.keys(fuseEnums).map((fuseEnum) => [
-        fuseEnum
-          .toLowerCase()
-          .replace(/([-_][a-z])/g, (group: string) =>
-            group.toUpperCase().replace('-', '').replace('_', ''),
-          ),
-        fuses.and(fuseEnums[fuseEnum as keyof typeof fuseEnums]).gt(0),
+      Object.keys(fuseEnum).map((fuse) => [
+        fuse,
+        fuses.and(fuseEnum[fuse as keyof typeof fuseEnum]).gt(0),
       ]),
     )
 
@@ -58,8 +44,10 @@ const decode = async (
       fuseObj,
       expiryDate,
       rawFuses: fuses,
+      owner,
     }
-  } catch {
+  } catch (e) {
+    console.error('Error decoding fuses data: ', e)
     return
   }
 }

package/src/functions/getHistory.test.ts

@@ -13,8 +13,6 @@ afterAll(async () => {
 })
 
 describe('getHistory', () => {
-  let textEventsWithValue: any[]
-
   it('should return null for a non-existent name', async () => {
     const result = await ENSInstance.getHistory('test123123cool.eth')
     expect(result).toBeUndefined()
@@ -28,86 +26,4 @@ describe('getHistory', () => {
       expect(result).toHaveProperty('registration')
     }
   })
-  describe('getHistoryWithDetail', () => {
-    it('should return null for a non-existent name', async () => {
-      const result = await ENSInstance.getHistoryWithDetail(
-        'test123123cool.eth',
-      )
-      expect(result).toBeUndefined()
-    })
-    it('should return the history of a name with TextChanged event detail', async () => {
-      const result = await ENSInstance.getHistoryWithDetail('with-profile.eth')
-      expect(result).toBeTruthy()
-      if (result) {
-        const textEvents = result.resolver.filter(
-          (x) => x.type === 'TextChanged',
-        )
-        textEvents.forEach((event) =>
-          expect(event.data).toHaveProperty('value'),
-        )
-        textEventsWithValue = textEvents
-      }
-    })
-  })
-  describe('getHistoryDetailForTransactionHash', () => {
-    it('should throw an error for an invalid transaction hash', async () => {
-      try {
-        await ENSInstance.getHistoryDetailForTransactionHash('0x234')
-        expect(false).toBeTruthy()
-      } catch (error) {
-        expect((error as any).message).toContain('invalid hash')
-      }
-    })
-    it('should return null for a transaction hash with no text events', async () => {
-      const result = await ENSInstance.getHistoryDetailForTransactionHash(
-        '0x0fd7b555e3076ef38dbbe2e40deefe44c9a0530d43f6b3f60dbed4ba49d229b7',
-      )
-      expect(result).toBeUndefined()
-    })
-    it('should return single item for a given transaction hash with one event', async () => {
-      const eventToUse = textEventsWithValue[0]
-      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
-        eventToUse.transactionHash,
-      )) as { key: any; value: any }[]
-      expect(result).toHaveLength(1)
-      if (result) {
-        expect(result[0]).toMatchObject(eventToUse.data)
-      }
-    })
-    let hash: string = ''
-    it('should return multiple items for a given transaction hash with multiple events', async () => {
-      const dataArr = [
-        { key: 'foo', value: 'bar' },
-        { key: 'swag', value: 'cool' },
-      ]
-      const tx = await ENSInstance.setRecords('test123.eth', {
-        records: {
-          texts: dataArr,
-        },
-        addressOrIndex: 1,
-      })
-      await tx.wait()
-
-      hash = tx.hash
-
-      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
-        hash,
-      )) as { key: any; value: any }[]
-      expect(result).toHaveLength(dataArr.length)
-      if (result) {
-        result.forEach((item, index) =>
-          expect(item).toMatchObject(dataArr[index]),
-        )
-      }
-    })
-    it('should return a single item when an index is specified for a hash', async () => {
-      const data = { key: 'swag', value: 'cool' }
-
-      const result = (await ENSInstance.getHistoryDetailForTransactionHash(
-        hash,
-        1,
-      )) as { key: any; value: any }
-      expect(result).toMatchObject(data)
-    })
-  })
 })