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

package/src/functions/batch.test.ts

@@ -10,23 +10,23 @@ beforeAll(async () => {
 describe('batch', () => {
   it('should batch calls together', async () => {
     const result = await ENSInstance.batch(
-      ENSInstance.getText.batch('jefflau.eth', 'description'),
-      ENSInstance.getAddr.batch('jefflau.eth'),
-      ENSInstance.getName.batch('0x866B3c4994e1416B7C738B9818b31dC246b95eEE'),
+      ENSInstance.getText.batch('with-profile.eth', 'description'),
+      ENSInstance.getAddr.batch('with-profile.eth'),
+      ENSInstance.getName.batch('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC'),
     )
     expect(result).toBeTruthy()
     if (result) {
       expect(result[0]).toBe('Hello2')
-      expect(result[1]).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+      expect(result[1]).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
       expect(result[2]).toMatchObject({
-        name: 'jefflau.eth',
+        name: 'with-profile.eth',
         match: true,
       })
     }
   })
   it('should batch a single call', async () => {
     const result = await ENSInstance.batch(
-      ENSInstance.getText.batch('jefflau.eth', 'description'),
+      ENSInstance.getText.batch('with-profile.eth', 'description'),
     )
     expect(result).toBeTruthy()
     if (result) {

package/src/functions/batchWrappers.test.ts

@@ -10,12 +10,12 @@ beforeAll(async () => {
 describe('batchWrappers', () => {
   it('should batch calls together', async () => {
     const batch = await ENSInstance.resolverMulticallWrapper.raw([
-      await ENSInstance._getText.raw('jefflau.eth', 'description'),
-      await ENSInstance._getText.raw('jefflau.eth', 'url'),
-      await ENSInstance._getAddr.raw('jefflau.eth'),
+      await ENSInstance._getText.raw('with-profile.eth', 'description'),
+      await ENSInstance._getText.raw('with-profile.eth', 'url'),
+      await ENSInstance._getAddr.raw('with-profile.eth'),
     ])
     const universalResponse = await ENSInstance.universalWrapper(
-      'jefflau.eth',
+      'with-profile.eth',
       batch.data,
     )
     const [batchDecoded] = await ENSInstance.resolverMulticallWrapper.decode(
@@ -26,6 +26,6 @@ describe('batchWrappers', () => {
     const decoded3 = await ENSInstance._getAddr.decode(batchDecoded[2])
     expect(decoded1).toBe('Hello2')
     expect(decoded2).toBe('twitter.com')
-    expect(decoded3).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+    expect(decoded3).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
   })
 })

package/src/functions/burnFuses.test.ts

@@ -1,4 +1,4 @@
-import { BigNumber, ethers } from 'ethers'
+import { ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 import { namehash } from '../utils/normalise'
@@ -22,24 +22,19 @@ describe('burnFuses', () => {
     await revert()
   })
   it('should return a burnFuses transaction and succeed', async () => {
-    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-
-    const tx = await ENSInstance.burnFuses('parthtejpal.eth', {
+    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 result = await nameWrapper.getFuses(namehash('parthtejpal.eth'))
-    const fuseBN = result.fuses as BigNumber
-    expect(fuseBN.toHexString()).toBe('0x71')
+    const [fuses] = await nameWrapper.getFuses(namehash('wrapped.eth'))
+    expect(fuses).toBe(113)
   })
 })

package/src/functions/burnFuses.ts

@@ -17,5 +17,5 @@ export default async function (
 
   const encodedFuses = generateFuseInput(fusesToBurn)
 
-  return nameWrapper.populateTransaction.burnFuses(hash, encodedFuses)
+  return nameWrapper.populateTransaction.setFuses(hash, encodedFuses)
 }

package/src/functions/createSubname.test.ts

@@ -23,33 +23,29 @@ describe('createSubname', () => {
     await revert()
   })
   it('should allow creating a subname on the registry', async () => {
-    const tx = await ENSInstance.createSubname('test.parthtejpal.eth', {
+    const tx = await ENSInstance.createSubname('test.test123.eth', {
       contract: 'registry',
       owner: accounts[0],
-      addressOrIndex: 0,
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(namehash('test.parthtejpal.eth'))
+    const result = await registry.owner(namehash('test.test123.eth'))
     expect(result).toBe(accounts[0])
   })
   it('should allow creating a subname on the namewrapper', async () => {
-    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const tx = await ENSInstance.createSubname('test.parthtejpal.eth', {
+    const tx = await ENSInstance.createSubname('test.wrapped.eth', {
       contract: 'nameWrapper',
       owner: accounts[0],
-      addressOrIndex: 0,
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.eth'))
+    const result = await nameWrapper.ownerOf(namehash('test.wrapped.eth'))
     expect(result).toBe(accounts[0])
   })
 })

package/src/functions/createSubname.ts

@@ -1,8 +1,9 @@
-import { ethers } from 'ethers'
+import { BigNumber, ethers } from 'ethers'
 import { ENSArgs } from '..'
 import { FuseOptions } from '../@types/FuseOptions'
 import generateFuseInput from '../utils/generateFuseInput'
 import { namehash } from '../utils/normalise'
+import { Expiry, makeExpiry } from '../utils/wrapperExpiry'
 
 type BaseArgs = {
   owner: string
@@ -13,12 +14,17 @@ type BaseArgs = {
 type NameWrapperArgs = {
   contract: 'nameWrapper'
   fuses?: FuseOptions
+  expiry?: Expiry
 } & BaseArgs
 
 type Args = BaseArgs | NameWrapperArgs
 
 export default async function (
-  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
+  {
+    contracts,
+    signer,
+    getExpiry,
+  }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>,
   name: string,
   { owner, resolverAddress, contract, ...wrapperArgs }: Args,
 ) {
@@ -54,6 +60,11 @@ export default async function (
     }
     case 'nameWrapper': {
       const nameWrapper = (await contracts?.getNameWrapper()!).connect(signer)
+      const expiry: BigNumber = await makeExpiry(
+        { getExpiry },
+        name,
+        'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined,
+      )
 
       const generatedFuses =
         'fuses' in wrapperArgs && wrapperArgs.fuses
@@ -67,6 +78,7 @@ export default async function (
         resolverAddress,
         0,
         generatedFuses,
+        expiry,
       )
     }
     default: {

package/src/functions/deleteSubname.test.ts

@@ -22,51 +22,32 @@ describe('deleteSubname', () => {
     await revert()
   })
   it('should allow deleting a subname on the registry', async () => {
-    const createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
-      {
-        contract: 'registry',
-        owner: accounts[0],
-        addressOrIndex: 0,
-      },
-    )
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.deleteSubname('test.parthtejpal.eth', {
+    const tx = await ENSInstance.deleteSubname('test.with-subnames.eth', {
       contract: 'registry',
-      addressOrIndex: 0,
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(namehash('test.parthtejpal.eth'))
+    const result = await registry.owner(namehash('test.with-subnames.eth'))
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
   it('should allow deleting a subname on the nameWrapper', async () => {
-    const wrapNameTx = await ENSInstance.wrapName('parthtejpal.eth', {
-      wrappedOwner: accounts[0],
-    })
-    await wrapNameTx.wait()
-    const createSubnameTx = await ENSInstance.createSubname(
-      'test.parthtejpal.eth',
+    const tx = await ENSInstance.deleteSubname(
+      'test.wrapped-with-subnames.eth',
       {
         contract: 'nameWrapper',
-        owner: accounts[0],
-        addressOrIndex: 0,
+        addressOrIndex: 1,
       },
     )
-    await createSubnameTx.wait()
-
-    const tx = await ENSInstance.deleteSubname('test.parthtejpal.eth', {
-      contract: 'nameWrapper',
-      addressOrIndex: 0,
-    })
     expect(tx).toBeTruthy()
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.eth'))
+    const result = await nameWrapper.ownerOf(
+      namehash('test.wrapped-with-subnames.eth'),
+    )
     expect(result).toBe('0x0000000000000000000000000000000000000000')
   })
 })

package/src/functions/deleteSubname.ts

@@ -1,7 +1,7 @@
 import { ENSArgs } from '..'
 
 export default async function (
-  { transferSubname }: ENSArgs<'transferSubname'>,
+  { transferSubname, signer }: ENSArgs<'transferSubname' | 'signer'>,
   name: string,
   {
     contract,
@@ -11,6 +11,7 @@ export default async function (
 ) {
   return transferSubname.populateTransaction(name, {
     contract,
-    address: '0x0000000000000000000000000000000000000000',
+    owner: '0x0000000000000000000000000000000000000000',
+    signer,
   })
 }

package/src/functions/getDNSOwner.test.ts

@@ -1,7 +1,5 @@
-import * as packet from 'dns-packet'
-import fetch from 'node-fetch'
 import nock from 'nock'
-
+import fetch from 'node-fetch'
 import getDNSOwner, { encodeURLParams } from './getDNSOwner'
 
 function hex_decode(string: string) {
@@ -39,7 +37,6 @@ describe('getDNSOwner', () => {
     })
       .get('/dns-query')
       .query((queryObject) => {
-        console.log('queryObject: ', queryObject)
         return (
           queryObject.ct === 'application/dns-udpwireformat' &&
           queryObject.dns ===
@@ -82,7 +79,6 @@ describe('getDNSOwner', () => {
     })
       .get('/dns-query')
       .query((queryObject) => {
-        console.log('queryObject: ', queryObject)
         return (
           queryObject.ct === 'application/dns-udpwireformat' &&
           queryObject.dns ===

package/src/functions/getExpiry.test.ts

@@ -17,8 +17,8 @@ afterAll(async () => {
 })
 
 describe('getExpiry', () => {
-  it('should get the expiry for a name', async () => {
-    const result = await ENSInstance.getExpiry('jefflau.eth')
+  it('should get the expiry for a .eth name with no other args', async () => {
+    const result = await ENSInstance.getExpiry('with-profile.eth')
     expect(result).toBeTruthy()
     if (result) {
       const { expiry, gracePeriod } = result
@@ -26,9 +26,31 @@ describe('getExpiry', () => {
       expect(gracePeriod).toBe(7776000000)
     }
   })
-  it('should throw an error for a non .eth name', async () => {
+  it('should get the expiry for a wrapped name', async () => {
+    const result = await ENSInstance.getExpiry('wrapped.eth', {
+      contract: 'nameWrapper',
+    })
+
+    expect(result).toBeTruthy()
+    if (result) {
+      const { expiry, gracePeriod } = result
+      expect(expiry).toBeInstanceOf(Date)
+      expect(gracePeriod).toBe(null)
+    }
+  })
+  it('should throw an error for a non .eth name if not wrapped', async () => {
+    try {
+      await ENSInstance.getExpiry('sub.with-profile.eth')
+      expect(false).toBeTruthy()
+    } catch {
+      expect(true).toBeTruthy()
+    }
+  })
+  it('should throw an error for a non .eth name if registrar is specified', async () => {
     try {
-      await ENSInstance.getExpiry('sub.jefflau.eth')
+      await ENSInstance.getExpiry('sub.with-profile.eth', {
+        contract: 'registrar',
+      })
       expect(false).toBeTruthy()
     } catch {
       expect(true).toBeTruthy()

package/src/functions/getExpiry.ts

@@ -1,19 +1,24 @@
 import { BigNumber } from 'ethers'
 import { solidityKeccak256 } from 'ethers/lib/utils'
 import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
 
-const raw = async (
-  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
-  name: string,
-) => {
-  const baseRegistrar = await contracts?.getBaseRegistrar()!
+type ContractOption = 'registrar' | 'nameWrapper'
 
-  const labels = name.split('.')
+type Args = {
+  contract?: ContractOption
+}
 
+const getRegistrarExpiry = async (
+  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  labels: string[],
+) => {
   if (labels.length > 2 || labels[1] !== 'eth') {
-    throw new Error('Only .eth names have expiry dates')
+    throw new Error('Only .eth names have expiry dates on the registrar')
   }
 
+  const baseRegistrar = await contracts?.getBaseRegistrar()!
+
   const expiryCall = baseRegistrar.interface.encodeFunctionData('nameExpires', [
     solidityKeccak256(['string'], [labels[0]]),
   ])
@@ -32,11 +37,49 @@ const raw = async (
   ])
 }
 
-const decode = async (
+const getWrapperExpiry = async (
+  { contracts }: ENSArgs<'contracts'>,
+  labels: string[],
+) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  const expiryCall = nameWrapper.interface.encodeFunctionData('getData', [
+    namehash(labels.join('.')),
+  ])
+  return {
+    to: nameWrapper.address,
+    data: expiryCall,
+  }
+}
+
+const getContractToUse = (
+  contract: ContractOption | undefined,
+  labels: string[],
+) => {
+  if (contract) return contract
+  if (labels.length === 2 && labels[1] === 'eth') {
+    return 'registrar'
+  }
+  return 'nameWrapper'
+}
+
+const raw = async (
+  ensArgs: ENSArgs<'contracts' | 'multicallWrapper'>,
+  name: string,
+  { contract }: Args = {},
+) => {
+  const labels = name.split('.')
+
+  const contractToUse = getContractToUse(contract, labels)
+
+  return contractToUse === 'nameWrapper'
+    ? getWrapperExpiry(ensArgs, labels)
+    : getRegistrarExpiry(ensArgs, labels)
+}
+
+const decodeRegistrarExpiry = async (
   { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
   data: string,
 ) => {
-  if (data === null) return
   const result = await multicallWrapper.decode(data)
   const baseRegistrar = await contracts?.getBaseRegistrar()!
   try {
@@ -57,6 +100,41 @@ const decode = async (
   }
 }
 
+const decodeWrapperExpiry = async (
+  { contracts }: ENSArgs<'contracts'>,
+  data: string,
+) => {
+  const nameWrapper = await contracts?.getNameWrapper()!
+  try {
+    const [_owner, _fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
+      'getData',
+      data,
+    )
+    return {
+      expiry: new Date(expiry * 1000),
+      gracePeriod: null,
+    }
+  } catch {
+    return
+  }
+}
+
+const decode = async (
+  ensArgs: ENSArgs<'contracts' | 'multicallWrapper'>,
+  data: string,
+  name: string,
+  { contract }: Args = {},
+) => {
+  if (data === null) return
+
+  const labels = name.split('.')
+  const contractToUse = getContractToUse(contract, labels)
+
+  return contractToUse === 'nameWrapper'
+    ? decodeWrapperExpiry(ensArgs, data)
+    : decodeRegistrarExpiry(ensArgs, data)
+}
+
 export default {
   raw,
   decode,

package/src/functions/getFuses.test.ts

@@ -12,10 +12,6 @@ let withWrappedSnapshot: any
 beforeAll(async () => {
   ;({ ENSInstance, revert, provider, createSnapshot } = await setup())
   accounts = await provider.listAccounts()
-  const tx = await ENSInstance.wrapName('parthtejpal.eth', {
-    wrappedOwner: accounts[0],
-  })
-  await tx.wait()
 
   withWrappedSnapshot = await createSnapshot()
 })
@@ -31,18 +27,12 @@ afterAll(async () => {
 
 describe('getFuses', () => {
   it('should return null for an unwrapped name', async () => {
-    const result = await ENSInstance.getFuses('jefflau.eth')
+    const result = await ENSInstance.getFuses('with-profile.eth')
     expect(result).toBeUndefined()
   })
   it('should return with canDoEverything set to true for a name with no fuses burned', async () => {
-    const tx = await ENSInstance.createSubname('test.parthtejpal.eth', {
-      contract: 'nameWrapper',
-      owner: accounts[0],
-      addressOrIndex: 0,
-    })
-    await tx.wait()
-
-    const result = await ENSInstance.getFuses('test.parthtejpal.eth')
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const result = await ENSInstance.getFuses('test.wrapped-with-subnames.eth')
     expect(result).toBeTruthy()
     if (result) {
       expect(result.fuseObj.canDoEverything).toBe(true)
@@ -56,15 +46,17 @@ describe('getFuses', () => {
     }
   })
   it('should return with other correct fuses', async () => {
-    const tx = await ENSInstance.burnFuses('parthtejpal.eth', {
+    const tx = await ENSInstance.burnFuses('wrapped.eth', {
       fusesToBurn: {
         cannotUnwrap: true,
         cannotSetTtl: true,
         cannotCreateSubdomain: true,
       },
+      addressOrIndex: 1,
     })
     await tx.wait()
-    const result = await ENSInstance.getFuses('parthtejpal.eth')
+
+    const result = await ENSInstance.getFuses('wrapped.eth')
     expect(result).toBeTruthy()
     if (result) {
       expect(result.fuseObj).toMatchObject({
@@ -80,26 +72,11 @@ describe('getFuses', () => {
       expect(result.rawFuses.toHexString()).toBe('0x71')
     }
   })
-  it('should return correct vulnerability data for an invulnerable node', async () => {
-    const result = await ENSInstance.getFuses('parthtejpal.eth')
-    expect(result).toBeTruthy()
-    if (result) {
-      expect(result.vulnerability).toBe('Safe')
-      expect(result.vulnerableNode).toBeNull()
-    }
-  })
-  it('should return correct vulnerability data for a vulnerable node', async () => {
-    const tx = await ENSInstance.createSubname('test.parthtejpal.eth', {
-      owner: accounts[0],
-      contract: 'nameWrapper',
-    })
-    await tx.wait()
-
-    const result = await ENSInstance.getFuses('test.parthtejpal.eth')
+  it('should return correct expiry', async () => {
+    const result = await ENSInstance.getFuses('wrapped.eth')
     expect(result).toBeTruthy()
     if (result) {
-      expect(result.vulnerability).toBe('SubdomainReplacementAllowed')
-      expect(result.vulnerableNode).toBe('parthtejpal.eth')
+      expect(result.expiryDate).toBeInstanceOf(Date)
     }
   })
 })

package/src/functions/getFuses.ts

@@ -1,4 +1,4 @@
-import { BigNumber, utils } from 'ethers'
+import { BigNumber } from 'ethers'
 import { ENSArgs } from '..'
 import { testable as fuseEnums } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
@@ -28,8 +28,12 @@ const decode = async (
 ) => {
   const nameWrapper = await contracts?.getNameWrapper()!
   try {
-    const [fuses, vulnerability, vulnerableNode] =
-      nameWrapper.interface.decodeFunctionResult('getFuses', data)
+    const [_fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
+      'getFuses',
+      data,
+    )
+
+    const fuses = BigNumber.from(_fuses)
 
     const fuseObj = Object.fromEntries(
       Object.keys(fuseEnums).map((fuseEnum) => [
@@ -48,22 +52,12 @@ const decode = async (
       fuseObj.canDoEverything = false
     }
 
-    let returnVulnerableNode: string | null = null
-    if (utils.hexStripZeros(vulnerableNode) !== '0x') {
-      name.split('.').forEach((label, index, arr) => {
-        const node = arr.slice(index).join('.')
-        const nodehash = namehash(node)
-        if (nodehash === vulnerableNode) {
-          returnVulnerableNode = node
-        }
-      })
-    }
+    const expiryDate = new Date(expiry * 1000)
 
     return {
       fuseObj,
-      vulnerability: NameSafety[vulnerability] || vulnerability,
-      vulnerableNode: returnVulnerableNode,
-      rawFuses: fuses as BigNumber,
+      expiryDate,
+      rawFuses: fuses,
     }
   } catch {
     return

package/src/functions/getHistory.test.ts

@@ -2,10 +2,14 @@ import { ENS } from '..'
 import setup from '../tests/setup'
 
 let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
-  jest.setTimeout(20000)
+  ;({ ENSInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
 })
 
 describe('getHistory', () => {
@@ -16,7 +20,7 @@ describe('getHistory', () => {
     expect(result).toBeUndefined()
   })
   it('should return the history of a name', async () => {
-    const result = await ENSInstance.getHistory('jefflau.eth')
+    const result = await ENSInstance.getHistory('with-profile.eth')
     expect(result).toBeTruthy()
     if (result) {
       expect(result).toHaveProperty('domain')
@@ -32,7 +36,7 @@ describe('getHistory', () => {
       expect(result).toBeUndefined()
     })
     it('should return the history of a name with TextChanged event detail', async () => {
-      const result = await ENSInstance.getHistoryWithDetail('jefflau.eth')
+      const result = await ENSInstance.getHistoryWithDetail('with-profile.eth')
       expect(result).toBeTruthy()
       if (result) {
         const textEvents = result.resolver.filter(
@@ -70,13 +74,22 @@ describe('getHistory', () => {
         expect(result[0]).toMatchObject(eventToUse.data)
       }
     })
+    let hash: string = ''
     it('should return multiple items for a given transaction hash with multiple events', async () => {
-      const hash =
-        '0x002b7cc3c85168d885a38226a28fac349d13cbaff7f3db4fa3af31f22b863079'
       const dataArr = [
-        { key: 'description', value: 'Not so super description' },
-        { key: 'url', value: 'facebook.com' },
+        { 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 }[]
@@ -88,9 +101,8 @@ describe('getHistory', () => {
       }
     })
     it('should return a single item when an index is specified for a hash', async () => {
-      const hash =
-        '0x002b7cc3c85168d885a38226a28fac349d13cbaff7f3db4fa3af31f22b863079'
-      const data = { key: 'url', value: 'facebook.com' }
+      const data = { key: 'swag', value: 'cool' }
+
       const result = (await ENSInstance.getHistoryDetailForTransactionHash(
         hash,
         1,