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

package/src/functions/getProfile.test.ts

@@ -1,11 +1,15 @@
+import { ethers } from 'ethers'
 import { ENS } from '..'
 import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert } = await setup())
+  ;({ ENSInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
 })
 
 afterAll(async () => {
@@ -15,14 +19,14 @@ afterAll(async () => {
 const checkRecords = (
   result: Record<string, any> | undefined,
   textLength = 3,
-  coinTypeLength = 5,
+  coinTypeLength = 3,
 ) => {
   expect(result).toBeDefined()
   if (result) {
     expect(result.records?.texts).toHaveLength(textLength)
     expect(result.records?.coinTypes).toHaveLength(coinTypeLength)
     expect(result.resolverAddress).toBe(
-      '0x42D63ae25990889E35F215bC95884039Ba354115',
+      '0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8',
     )
   }
 }
@@ -33,30 +37,30 @@ describe('getProfile', () => {
   describe('with an address', () => {
     it('should return a profile object with no other args', async () => {
       const result = await ENSInstance.getProfile(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
       expect(result).toBeDefined()
       if (result) {
-        expect((result as any).name).toBe('jefflau.eth')
+        expect((result as any).name).toBe('with-profile.eth')
         expect((result as any).address).toBeUndefined()
         checkRecords(result)
       }
     })
     it('should return a profile object with specified records', async () => {
       const result = await ENSInstance.getProfile(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
         { texts: ['description', 'url'], coinTypes: ['ETC', '0'] },
       )
       expect(result).toBeDefined()
       if (result) {
-        expect((result as any).name).toBe('jefflau.eth')
+        expect((result as any).name).toBe('with-profile.eth')
         expect((result as any).address).toBeUndefined()
         checkRecords(result, 2, 3)
       }
     })
     it('should return a profile object with all of each specified record type', async () => {
       const result = await ENSInstance.getProfile(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
         { texts: true, coinTypes: true },
       )
       checkRecords(result)
@@ -70,37 +74,42 @@ describe('getProfile', () => {
   })
   describe('with a name', () => {
     it('should return a profile object with no other args', async () => {
-      const result = await ENSInstance.getProfile('jefflau.eth')
+      const result = await ENSInstance.getProfile('with-profile.eth')
       expect((result as any).address).toBe(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
       checkRecords(result)
     })
     it('should return a profile object with specified records', async () => {
-      const result = await ENSInstance.getProfile('jefflau.eth', {
+      const result = await ENSInstance.getProfile('with-profile.eth', {
         texts: ['description', 'url'],
         coinTypes: ['ETC', '0'],
       })
       expect((result as any).address).toBe(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
       checkRecords(result, 2, 3)
     })
     it('should return a profile object with all of each specified record type', async () => {
-      const result = await ENSInstance.getProfile('jefflau.eth', {
+      const result = await ENSInstance.getProfile('with-profile.eth', {
         texts: true,
         coinTypes: true,
       })
       checkRecords(result)
     })
     it('should return a profile object for a specified resolver', async () => {
-      const result = await ENSInstance.getProfile('saganaki.xyz', {
-        resolverAddress: '0x12299799a50340fb860d276805e78550cbad3de3',
+      const tx = await ENSInstance.wrapName('test123.eth', {
+        wrappedOwner: accounts[1],
+        addressOrIndex: 1,
+      })
+      await tx.wait()
+      const result = await ENSInstance.getProfile('test123.eth', {
+        resolverAddress: '0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8',
       })
       expect(result).toBeDefined()
-      expect(result?.address).toBe('0x157545BfD441453921049998128Ff090c1c11230')
+      expect(result?.address).toBe(accounts[1])
       expect(result?.resolverAddress).toBe(
-        '0x12299799a50340fb860d276805e78550cbad3de3',
+        '0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8',
       )
     })
     it('should return undefined for an unregistered name', async () => {
@@ -110,22 +119,21 @@ describe('getProfile', () => {
   })
   describe('with an old resolver', () => {
     it('should use fallback methods for a name with an older resolver (no multicall)', async () => {
-      const result = await ENSInstance.getProfile('pepeq6.eth')
+      const result = await ENSInstance.getProfile('with-legacy-resolver.eth')
       expect(result).toBeDefined()
       if (result) {
         expect(result.address).toBe(
-          '0x6308F1c6f283583C8bf8E31Da793B87718b051eD',
+          '0x70997970C51812dc3A010C7d01b50e0d17dc79C8',
+        )
+        expect(result.resolverAddress).toBe(
+          '0x5f3f1dbd7b74c6b46e8c44f98792a1daf8d69154',
         )
       }
     })
   })
   describe('with an unmigrated name', () => {
-    beforeAll(async () => {
-      ;({ ENSInstance } = await setup(true))
-      jest.setTimeout(20000)
-    })
     it('should return an object with isMigrated false and a message', async () => {
-      const result = await ENSInstance.getProfile('jefflau.test')
+      const result = await ENSInstance.getProfile('legacy.test')
       expect(result).toBeTruthy()
       if (result) {
         expect(result.isMigrated).toBe(false)

package/src/functions/getProfile.ts

@@ -362,7 +362,7 @@ const graphFetch = async (
     ;({ domain } = await client.request(query, { id }))
     resolverResponse = domain?.resolver
   } else {
-    const resolverId = `${resolverAddress}-${id}`
+    const resolverId = `${resolverAddress.toLowerCase()}-${id}`
     ;({ resolver: resolverResponse, domain } = await client.request(
       customResolverQuery,
       { id, resolverId },

package/src/functions/getResolver.test.ts

@@ -9,11 +9,7 @@ beforeAll(async () => {
 
 describe('getResolver', () => {
   it('should find the resolver for a name with a resolver', async () => {
-    const result = await ENSInstance.getResolver('jefflau.eth')
-    expect(result).toBe('0x42D63ae25990889E35F215bC95884039Ba354115')
-  })
-  it('should return .eth resolver for an unregistered name', async () => {
-    const result = await ENSInstance.getResolver('test123123cool.eth')
-    expect(result).toBe('0x3E8Dc215A6E404A7Ba811DE5Da3ff2A809AE94E2')
+    const result = await ENSInstance.getResolver('with-profile.eth')
+    expect(result).toBe('0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8')
   })
 })

package/src/functions/getSpecificRecord.test.ts

@@ -14,11 +14,11 @@ describe('getSpecificRecord', () => {
       expect(result).toBeUndefined()
     })
     it('should return null for a name with no contenthash record', async () => {
-      const result = await ENSInstance.getContentHash('jefflau.eth')
+      const result = await ENSInstance.getContentHash('with-profile.eth')
       expect(result).toBeUndefined()
     })
     it('should return the contenthash for a name with the record set', async () => {
-      const result = await ENSInstance.getContentHash('matoken.eth')
+      const result = await ENSInstance.getContentHash('with-contenthash.eth')
       expect(result).toMatchObject({
         protocolType: 'ipfs',
         decoded: 'bafybeico3uuyj3vphxpvbowchdwjlrlrh62awxscrnii7w7flu5z6fk77y',
@@ -29,13 +29,16 @@ describe('getSpecificRecord', () => {
 
   describe('getText', () => {
     it('should return a record from a key', async () => {
-      const result = await ENSInstance.getText('jefflau.eth', 'description')
+      const result = await ENSInstance.getText(
+        'with-profile.eth',
+        'description',
+      )
       expect(result).toBe('Hello2')
     })
 
     it('should return null for a non-existent key', async () => {
       const result = await ENSInstance.getText(
-        'jefflau.eth',
+        'with-profile.eth',
         'thiskeydoesntexist',
       )
       expect(result).toBeUndefined()
@@ -44,32 +47,32 @@ describe('getSpecificRecord', () => {
 
   describe('getAddr', () => {
     it('should return the ETH addr record if no coinType is provided', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth')
-      expect(result).toBe('0x866B3c4994e1416B7C738B9818b31dC246b95eEE')
+      const result = await ENSInstance.getAddr('with-profile.eth')
+      expect(result).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
     })
     it('should return the correct address based on a coin ID input as a number', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth', 61)
+      const result = await ENSInstance.getAddr('with-profile.eth', 61)
       expect((result as any).addr).toBe(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
       expect((result as any).coin).toBe('ETC')
     })
     it('should return the correct address based on a coin ID input as a string', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth', '61')
+      const result = await ENSInstance.getAddr('with-profile.eth', '61')
       expect((result as any).addr).toBe(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
       expect((result as any).coin).toBe('ETC')
     })
     it('should return the correct address based on a coin name', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth', 'ETC')
+      const result = await ENSInstance.getAddr('with-profile.eth', 'ETC')
       expect((result as any).addr).toBe(
-        '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       )
       expect((result as any).coin).toBe('ETC')
     })
     it('should return null for a non-existent coin', async () => {
-      const result = await ENSInstance.getAddr('jefflau.eth', 'BNB')
+      const result = await ENSInstance.getAddr('with-profile.eth', 'BNB')
       expect(result).toBeUndefined()
     })
   })

package/src/functions/getSpecificRecord.ts

@@ -15,11 +15,17 @@ export const _getContentHash = {
     }
   },
   decode: async ({ contracts }: ENSArgs<'contracts'>, data: string) => {
+    let response: any
     const publicResolver = await contracts?.getPublicResolver()!
-    const [response] = publicResolver.interface.decodeFunctionResult(
-      'contenthash',
-      data,
-    )
+    try {
+      ;[response] = publicResolver.interface.decodeFunctionResult(
+        'contenthash',
+        data,
+      )
+    } catch {
+      return
+    }
+
     if (!response) {
       return
     }

package/src/functions/getSubnames.test.ts

@@ -11,21 +11,25 @@ const testProperties = (obj: object, ...properties: string[]) =>
   properties.map((property) => expect(obj).toHaveProperty(property))
 
 describe('getSubnames', () => {
-  it('should get the subnames for a name', async () => {
-    const result = await ENSInstance.getSubnames({
-      name: 'jefflau.eth',
-    })
-    expect(result).toBeTruthy()
-    expect(result.length).toBeGreaterThan(0)
-    testProperties(
-      result[0],
-      'id',
-      'labelName',
-      'labelhash',
-      'name',
-      'isMigrated',
-      'owner',
-      'truncatedName',
-    )
-  })
+  it.todo('should get the subnames for a name')
+  // it('should get the subnames for a name', async () => {
+  //   const result = await ENSInstance.getSubnames({
+  //     name: 'with-profile.eth',
+  //   })
+  //   expect(result).toBeTruthy()
+  //   if (result) {
+  //     console.log(result)
+  //     expect(result.length).toBeGreaterThan(0)
+  //     testProperties(
+  //       result[0],
+  //       'id',
+  //       'labelName',
+  //       'labelhash',
+  //       'name',
+  //       'isMigrated',
+  //       'owner',
+  //       'truncatedName',
+  //     )
+  //   }
+  // })
 })

package/src/functions/getSubnames.ts

@@ -21,13 +21,20 @@ type Params = {
   pageSize?: number
   orderDirection?: 'asc' | 'desc'
   orderBy?: 'createdAt' | 'labelName'
-  lastSubnames: Array<any>
+  lastSubnames?: Array<any>
   isLargeQuery?: boolean
 }
 
 const largeQuery = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
-  { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }: Params,
+  {
+    name,
+    page,
+    pageSize = 10,
+    orderDirection,
+    orderBy,
+    lastSubnames = [],
+  }: Params,
 ) => {
   const client = gqlInstance.client
 

package/src/functions/makeCommitment.test.ts

@@ -1,6 +1,6 @@
 import { ENS } from '..'
-import { makeCommitment } from '../utils/registerHelpers'
 import setup from '../tests/setup'
+import { makeCommitment } from '../utils/registerHelpers'
 
 let ENSInstance: ENS
 
@@ -13,7 +13,7 @@ describe('makeCommitment', () => {
     const resolver = await ENSInstance.contracts!.getPublicResolver()!
     const commitment = makeCommitment({
       name: 'test.eth',
-      owner: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      owner: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       duration: 1 * 365 * 24 * 60 * 60,
       resolver: resolver,
     })

package/src/functions/registerName.test.ts

@@ -0,0 +1,59 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { namehash } from '../utils/normalise'
+
+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()
+  await provider.send('anvil_removeBlockTimestampInterval', [])
+})
+
+describe('registerName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a registration transaction and succeed', async () => {
+    const name = 'cool-swag.eth'
+    const duration = 31536000
+    const { customData, ...commitPopTx } =
+      await ENSInstance.commitName.populateTransaction(name, {
+        duration,
+        owner: accounts[1],
+        addressOrIndex: accounts[1],
+      })
+    const commitTx = await provider.getSigner().sendTransaction(commitPopTx)
+    await commitTx.wait()
+
+    await provider.send('evm_increaseTime', [60])
+    await provider.send('evm_mine', [])
+
+    const { secret, wrapperExpiry } = customData!
+
+    const controller = await ENSInstance.contracts!.getEthRegistrarController()!
+    const [price] = await controller.rentPrice(name, duration)
+
+    const tx = await ENSInstance.registerName(name, {
+      secret,
+      wrapperExpiry,
+      duration,
+      owner: accounts[1],
+      addressOrIndex: accounts[1],
+      value: price,
+    })
+    await tx.wait()
+
+    const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
+    const owner = await nameWrapper.ownerOf(namehash(name))
+    expect(owner).toBe(accounts[1])
+  })
+})

package/src/functions/registerName.ts

@@ -0,0 +1,38 @@
+import { BigNumber } from 'ethers'
+import { ENSArgs } from '..'
+import {
+  CommitmentParams,
+  makeRegistrationData,
+} from '../utils/registerHelpers'
+
+type Params = Omit<CommitmentParams, 'name' | 'resolver'> & {
+  resolverAddress?: string
+  secret: string
+  wrapperExpiry: number
+  value: BigNumber
+}
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  { resolverAddress, value, ...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 generatedParams = makeRegistrationData({
+    name,
+    resolver: _resolver,
+    ...params,
+  })
+
+  return controller.populateTransaction.register(...generatedParams, {
+    value,
+  })
+}

package/src/functions/renewName.test.ts

@@ -0,0 +1,44 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { labelhash } from '../utils/labels'
+
+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('registerName', () => {
+  beforeEach(async () => {
+    await revert()
+  })
+  it('should return a renew transaction and succeed', async () => {
+    const name = 'to-be-renewed.eth'
+    const label = name.split('.')[0]
+    const duration = 31536000
+    const baseRegistrar = await ENSInstance.contracts!.getBaseRegistrar()!
+    const oldExpiry = await baseRegistrar.nameExpires(labelhash(label))
+
+    const controller = await ENSInstance.contracts!.getEthRegistrarController()!
+    const [price] = await controller.rentPrice(label, duration)
+
+    const tx = await ENSInstance.renewName(name, {
+      value: price.mul(2),
+      duration,
+      addressOrIndex: accounts[1],
+    })
+    await tx.wait()
+
+    const newExpiry = await baseRegistrar.nameExpires(labelhash(label))
+    expect(newExpiry.toNumber()).toBe(oldExpiry.add(31536000).toNumber())
+  })
+})

package/src/functions/renewName.ts

@@ -0,0 +1,22 @@
+import type { BigNumber } from 'ethers'
+import { ENSArgs } from '..'
+
+export default async function (
+  { contracts }: ENSArgs<'contracts'>,
+  name: string,
+  {
+    duration,
+    value,
+  }: {
+    duration: number
+    value: BigNumber
+  },
+) {
+  const labels = name.split('.')
+  if (labels.length !== 2 || labels[1] !== 'eth')
+    throw new Error('Currently only .eth TLD renewals are supported')
+
+  const controller = await contracts!.getEthRegistrarController()
+
+  return controller.populateTransaction.renew(labels[0], duration, { value })
+}

package/src/functions/setName.test.ts

@@ -22,38 +22,37 @@ describe('setName', () => {
     await revert()
   })
   it('should return a transaction for a name and set successfully', async () => {
-    const tx = await ENSInstance.setName('fleek.eth')
+    const tx = await ENSInstance.setName('test123.eth', { addressOrIndex: 1 })
     expect(tx).toBeTruthy()
     await tx?.wait()
 
     const universalResolver =
       await ENSInstance.contracts!.getUniversalResolver()!
-    const reverseNode = accounts[0].toLowerCase().substring(2) + '.addr.reverse'
+    const reverseNode = accounts[1].toLowerCase().substring(2) + '.addr.reverse'
     const result = await universalResolver.reverse(hexEncodeName(reverseNode))
-    expect(result[0]).toBe('fleek.eth')
+    expect(result[0]).toBe('test123.eth')
   })
   it("should return a transaction for setting another address' name", async () => {
-    jest.setTimeout(20000)
     const registry = (await ENSInstance.contracts!.getRegistry()!).connect(
-      provider.getSigner(),
+      provider.getSigner(1),
     )
     const setApprovedForAllTx = await registry.setApprovalForAll(
-      accounts[1],
+      accounts[2],
       true,
     )
     await setApprovedForAllTx?.wait()
 
-    const tx = await ENSInstance.setName('fleek.eth', {
-      address: accounts[0],
-      addressOrIndex: 1,
+    const tx = await ENSInstance.setName('test123.eth', {
+      address: accounts[1],
+      addressOrIndex: 2,
     })
     expect(tx).toBeTruthy()
     await tx?.wait()
 
     const universalResolver =
       await ENSInstance.contracts!.getUniversalResolver()!
-    const reverseNode = accounts[0].toLowerCase().substring(2) + '.addr.reverse'
+    const reverseNode = accounts[1].toLowerCase().substring(2) + '.addr.reverse'
     const result = await universalResolver.reverse(hexEncodeName(reverseNode))
-    expect(result[0]).toBe('fleek.eth')
+    expect(result[0]).toBe('test123.eth')
   })
 })

package/src/functions/setRecord.test.ts

@@ -17,9 +17,10 @@ afterAll(async () => {
 
 describe('setRecord', () => {
   it('should allow a text record set', async () => {
-    const tx = await ENSInstance.setRecord('parthtejpal.eth', {
+    const tx = await ENSInstance.setRecord('test123.eth', {
       type: 'text',
       record: { key: 'foo', value: 'bar' },
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
@@ -28,9 +29,9 @@ describe('setRecord', () => {
       await ENSInstance.contracts!.getUniversalResolver()!
     const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
     const encodedText = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
       publicResolver.interface.encodeFunctionData('text', [
-        namehash('parthtejpal.eth'),
+        namehash('test123.eth'),
         'foo',
       ]),
     )
@@ -41,12 +42,13 @@ describe('setRecord', () => {
     expect(resultText).toBe('bar')
   })
   it('should allow an address record set', async () => {
-    const tx = await ENSInstance.setRecord('parthtejpal.eth', {
+    const tx = await ENSInstance.setRecord('test123.eth', {
       type: 'addr',
       record: {
         key: 'ETC',
         value: '0x42D63ae25990889E35F215bC95884039Ba354115',
       },
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
@@ -55,9 +57,9 @@ describe('setRecord', () => {
       await ENSInstance.contracts!.getUniversalResolver()!
     const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
     const encodedAddr = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
       publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
-        namehash('parthtejpal.eth'),
+        namehash('test123.eth'),
         '61',
       ]),
     )
@@ -70,10 +72,11 @@ describe('setRecord', () => {
     )
   })
   it('should allow a contenthash record set', async () => {
-    const tx = await ENSInstance.setRecord('parthtejpal.eth', {
+    const tx = await ENSInstance.setRecord('test123.eth', {
       type: 'contentHash',
       record:
         'ipns://k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
+      addressOrIndex: 1,
     })
     expect(tx).toBeTruthy()
     await tx.wait()
@@ -82,9 +85,9 @@ describe('setRecord', () => {
       await ENSInstance.contracts!.getUniversalResolver()!
     const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
     const encodedContent = await universalResolver.resolve(
-      hexEncodeName('parthtejpal.eth'),
+      hexEncodeName('test123.eth'),
       publicResolver.interface.encodeFunctionData('contenthash', [
-        namehash('parthtejpal.eth'),
+        namehash('test123.eth'),
       ]),
     )
     const [resultContent] = publicResolver.interface.decodeFunctionResult(