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

package/src/tests/getOwner.test.ts

@@ -42,6 +42,16 @@ describe('getOwner', () => {
     expect(result?.ownershipLevel).toBe('registrar')
     expect(result?.registrant).toBe(nameWrapperAddress)
   })
+  it('should return the owner of a TLD on the registry', async () => {
+    const result = await ENSInstance.getOwner('eth')
+    const baseRegistrarAddress = (
+      await ENSInstance.contracts!.getBaseRegistrar()
+    ).address
+    expect(result?.ownershipLevel).toBe('registry')
+    expect(result?.owner?.toLowerCase()).toBe(
+      baseRegistrarAddress.toLowerCase(),
+    )
+  })
   // it('should return registry as the ownership level for an unwrapped subname', async () => {
   //   const result0 = await ENSInstance.getOwner('fleek.eth')
   //   console.log(result0?.owner, accounts[2])

package/src/tests/getProfile.test.ts

@@ -8,11 +8,11 @@ beforeAll(async () => {
 })
 
 const checkRecords = (
-  result: Record<string, any> | null,
+  result: Record<string, any> | undefined,
   textLength = 3,
   coinTypeLength = 5,
 ) => {
-  expect(result).toBeTruthy()
+  expect(result).toBeDefined()
   if (result) {
     expect(result.records?.texts).toHaveLength(textLength)
     expect(result.records?.coinTypes).toHaveLength(coinTypeLength)
@@ -22,24 +22,32 @@ const checkRecords = (
   }
 }
 
+jest.setTimeout(20000)
+
 describe('getProfile', () => {
   describe('with an address', () => {
     it('should return a profile object with no other args', async () => {
       const result = await ENSInstance.getProfile(
         '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
       )
-      expect((result as any).name).toBe('jefflau.eth')
-      expect((result as any).address).toBeUndefined()
-      checkRecords(result)
+      expect(result).toBeDefined()
+      if (result) {
+        expect((result as any).name).toBe('jefflau.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',
         { texts: ['description', 'url'], coinTypes: ['ETC', '0'] },
       )
-      expect((result as any).name).toBe('jefflau.eth')
-      expect((result as any).address).toBeUndefined()
-      checkRecords(result, 2, 3)
+      expect(result).toBeDefined()
+      if (result) {
+        expect((result as any).name).toBe('jefflau.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(
@@ -80,11 +88,22 @@ describe('getProfile', () => {
       })
       checkRecords(result)
     })
-    it('should return null for an unregistered name', async () => {
+    it('should return undefined for an unregistered name', async () => {
       const result = await ENSInstance.getProfile('test123123123cool.eth')
       expect(result).toBeUndefined()
     })
   })
+  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')
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBe(
+          '0x6308F1c6f283583C8bf8E31Da793B87718b051eD',
+        )
+      }
+    })
+  })
   describe('with an unmigrated name', () => {
     beforeAll(async () => {
       ;({ ENSInstance } = await setup(true))
@@ -95,7 +114,6 @@ describe('getProfile', () => {
       expect(result).toBeTruthy()
       if (result) {
         expect(result.isMigrated).toBe(false)
-        expect(result.message).toBe("Records fetch didn't complete")
       }
     })
   })

package/src/tests/normalise.test.ts

@@ -0,0 +1,22 @@
+import { namehash } from '../utils/normalise'
+
+describe('normalise', () => {
+  it('should namehash an empty string', () => {
+    const hash = namehash('')
+    expect(hash).toEqual(
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+    )
+  })
+  it('should namehash a TLD', () => {
+    const hash = namehash('eth')
+    expect(hash).toEqual(
+      '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+    )
+  })
+  it('should namehash a 2LD', () => {
+    const hash = namehash('foo.eth')
+    expect(hash).toEqual(
+      '0xde9b09fd7c5f901e23a3f19fecc54828e9c848539801e86591bd9801b019f84f',
+    )
+  })
+})

package/src/tests/setRecords.test.ts

@@ -1,6 +1,6 @@
-import { utils } from 'ethers'
 import { ENS } from '..'
 import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
 import setup from './setup'
 
 let ENSInstance: ENS
@@ -31,14 +31,14 @@ describe('setRecords', () => {
     const encodedText = await universalResolver.resolve(
       hexEncodeName('parthtejpal.eth'),
       publicResolver.interface.encodeFunctionData('text(bytes32,string)', [
-        utils.namehash('parthtejpal.eth'),
+        namehash('parthtejpal.eth'),
         'foo',
       ]),
     )
     const encodedAddr = await universalResolver.resolve(
       hexEncodeName('parthtejpal.eth'),
       publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
-        utils.namehash('parthtejpal.eth'),
+        namehash('parthtejpal.eth'),
         '61',
       ]),
     )

package/src/tests/transferName.test.ts

@@ -1,5 +1,6 @@
 import { ethers, utils } from 'ethers'
 import { ENS } from '..'
+import { namehash } from '../utils/normalise'
 import setup from './setup'
 
 let ENSInstance: ENS
@@ -52,7 +53,7 @@ describe('transferName', () => {
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(utils.namehash('parthtejpal.eth'))
+    const result = await nameWrapper.ownerOf(namehash('parthtejpal.eth'))
     expect(result).toBe(accounts[1])
   })
   it('should allow a transfer on the registry', async () => {
@@ -74,7 +75,7 @@ describe('transferName', () => {
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(utils.namehash('test.parthtejpal.eth'))
+    const result = await registry.owner(namehash('test.parthtejpal.eth'))
     expect(result).toBe(accounts[1])
   })
 })

package/src/tests/transferSubname.test.ts

@@ -1,5 +1,6 @@
-import { ethers, utils } from 'ethers'
+import { ethers } from 'ethers'
 import { ENS } from '..'
+import { namehash } from '../utils/normalise'
 import setup from './setup'
 
 let ENSInstance: ENS
@@ -39,7 +40,7 @@ describe('transferSubname', () => {
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(utils.namehash('test.parthtejpal.eth'))
+    const result = await registry.owner(namehash('test.parthtejpal.eth'))
     expect(result).toBe(accounts[1])
   })
   it('should allow transferring a subname on the nameWrapper', async () => {
@@ -66,9 +67,7 @@ describe('transferSubname', () => {
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const result = await nameWrapper.ownerOf(
-      utils.namehash('test.parthtejpal.eth'),
-    )
+    const result = await nameWrapper.ownerOf(namehash('test.parthtejpal.eth'))
     expect(result).toBe(accounts[1])
   })
 })

package/src/tests/unwrapName.test.ts

@@ -1,5 +1,6 @@
 import { ethers, utils } from 'ethers'
 import { ENS } from '..'
+import { namehash } from '../utils/normalise'
 import setup from './setup'
 
 let ENSInstance: ENS
@@ -61,7 +62,7 @@ describe('unwrapName', () => {
     await tx.wait()
 
     const registry = await ENSInstance.contracts!.getRegistry()!
-    const result = await registry.owner(utils.namehash('test.parthtejpal.eth'))
+    const result = await registry.owner(namehash('test.parthtejpal.eth'))
     expect(result).toBe(accounts[0])
   })
 })

package/src/tests/wrapName.test.ts

@@ -1,6 +1,7 @@
-import { BigNumber, ethers, utils } from 'ethers'
+import { BigNumber, ethers } from 'ethers'
 import { ENS } from '..'
 import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
 import setup from './setup'
 
 let ENSInstance: ENS
@@ -28,9 +29,7 @@ describe('wrapName', () => {
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const [result] = await nameWrapper.getFuses(
-      utils.namehash('parthtejpal.eth'),
-    )
+    const [result] = await nameWrapper.getFuses(namehash('parthtejpal.eth'))
     expect((result as BigNumber).toHexString()).toBe('0x40')
   })
   it('should allow initial fuses', async () => {
@@ -42,9 +41,7 @@ describe('wrapName', () => {
     await tx.wait()
 
     const nameWrapper = await ENSInstance.contracts!.getNameWrapper()!
-    const [result] = await nameWrapper.getFuses(
-      utils.namehash('parthtejpal.eth'),
-    )
+    const [result] = await nameWrapper.getFuses(namehash('parthtejpal.eth'))
     expect((result as BigNumber).toHexString()).toBe('0x51')
   })
   it('should allow an initial resolver address', async () => {

package/src/utils/makeHashIndexes.ts

@@ -1,9 +1,9 @@
-import { ethers } from 'ethers'
+import { namehash } from './normalise'
 
 export const makeOtherIndexes = (data: string, findStr: string) =>
   Array.from(data.matchAll(findStr as any)).map((x: any) => x.index / 2 - 1)
 
 export const makeNamehashIndexes = (data: string, name: string) =>
-  Array.from(
-    data.matchAll(ethers.utils.namehash(name).substring(2) as any),
-  ).map((x: any) => x.index / 2 - 1)
+  Array.from(data.matchAll(namehash(name).substring(2) as any)).map(
+    (x: any) => x.index / 2 - 1,
+  )

package/src/utils/normalise.ts

@@ -1,4 +1,27 @@
+import { concat, hexlify, keccak256, toUtf8Bytes } from 'ethers/lib/utils'
 import uts46 from 'idna-uts46-hx/uts46bundle.js'
 
+const zeros = new Uint8Array(32)
+zeros.fill(0)
+
 export const normalise = (name: string) =>
   name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name
+
+export const namehash = (inputName: string): string => {
+  let result: string | Uint8Array = zeros
+
+  const name = normalise(inputName)
+
+  if (name) {
+    const labels = name.split('.')
+
+    for (var i = labels.length - 1; i >= 0; i--) {
+      const labelSha = keccak256(toUtf8Bytes(labels[i]))
+      result = keccak256(concat([result, labelSha]))
+    }
+  } else {
+    result = hexlify(zeros)
+  }
+
+  return result as string
+}

package/src/utils/registerHelpers.ts

@@ -3,6 +3,7 @@ import type { FuseOptions } from '../@types/FuseOptions'
 import type { PublicResolver } from '../generated'
 import generateFuseInput from './generateFuseInput'
 import { labelhash } from './labels'
+import { namehash } from './normalise'
 import { generateRecordCallArray, RecordOptions } from './recordHelpers'
 
 export const randomSecret = () => {
@@ -28,11 +29,9 @@ export const makeCommitment = ({
   fuses?: FuseOptions
 }) => {
   const label = labelhash(name.split('.')[0])
-  const namehash = utils.namehash(name)
+  const hash = namehash(name)
   const resolverAddress = resolver.address
-  const data = records
-    ? generateRecordCallArray(namehash, records, resolver)
-    : []
+  const data = records ? generateRecordCallArray(hash, records, resolver) : []
   const secret = randomSecret()
   const fuseData = fuses ? generateFuseInput(fuses) : '0'