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

package/src/{tests → functions}/getNames.test.ts

@@ -1,6 +1,6 @@
 import { ENS } from '..'
-import { OwnedName, Registration } from '../functions/getNames'
-import setup from './setup'
+import setup from '../tests/setup'
+import { Name } from './getNames'
 
 let ENSInstance: ENS
 
@@ -14,12 +14,43 @@ const testProperties = (obj: object, ...properties: string[]) =>
 const testNotProperties = (obj: object, ...properties: string[]) =>
   properties.map((property) => expect(obj).not.toHaveProperty(property))
 
+const letterItems = [
+  'w',
+  '9',
+  '8',
+  '7',
+  '6',
+  '5',
+  '4',
+  ...Array(5).fill('3'),
+  ...Array(11).fill('2'),
+  ...Array(11).fill('1'),
+  '0',
+]
+
+const domainLetterItems = [
+  '[',
+  'w',
+  't',
+  't',
+  '9',
+  '8',
+  '7',
+  '6',
+  '5',
+  '4',
+  ...Array(5).fill('3'),
+  ...Array(11).fill('2'),
+  ...Array(11).fill('1'),
+  '0',
+]
+
 describe('getNames', () => {
   let totalRegistrations: number = 0
   let totalOwnedNames: number = 0
   it('should get the registrations for an address', async () => {
     const result = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'registrant',
     })
     totalRegistrations = result.length
@@ -39,7 +70,7 @@ describe('getNames', () => {
   })
   it('should get the owned names for an address', async () => {
     const result = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
     })
     totalOwnedNames = result.length
@@ -58,39 +89,51 @@ describe('getNames', () => {
   })
   it('should get the registrations for an address with pagination', async () => {
     const pageOne = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'registrant',
       page: 0,
     })
     expect(pageOne).toHaveLength(10)
     const pageTwo = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'registrant',
       page: 1,
     })
-    expect(pageTwo).toHaveLength(totalRegistrations % 10)
+    expect(pageTwo).toHaveLength(10)
+    const pageThree = await ENSInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'registrant',
+      page: 2,
+    })
+    expect(pageThree).toHaveLength(10)
+    const pageFour = await ENSInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'registrant',
+      page: 3,
+    })
+    expect(pageFour).toHaveLength(totalRegistrations % 10)
   })
   it('should get the owned names for an address with pagination', async () => {
     const pageOne = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
       page: 0,
     })
     expect(pageOne).toHaveLength(10)
     const pageTwo = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
       page: 1,
     })
     expect(pageTwo).toHaveLength(10)
     const pageThree = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
       page: 2,
     })
     expect(pageThree).toHaveLength(10)
     const pageFour = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
       page: 3,
     })
@@ -100,147 +143,133 @@ describe('getNames', () => {
     describe('registrations', () => {
       it('descending registrationDate', async () => {
         const registrationDateOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'registrationDate',
           orderDirection: 'desc',
-        })) as Registration[]
+        })) as Name[]
         registrationDateOrderedDesc.reduce((prev, curr) => {
-          expect(prev.registrationDate.getTime()).toBeGreaterThanOrEqual(
-            curr.registrationDate.getTime(),
+          expect(prev.registrationDate!.getTime()).toBeGreaterThanOrEqual(
+            curr.registrationDate!.getTime(),
           )
           return curr
         })
       })
       it('ascending registrationDate', async () => {
         const registrationDateOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'registrationDate',
           orderDirection: 'asc',
-        })) as Registration[]
+        })) as Name[]
         registrationDateOrderedAsc.reduce((prev, curr) => {
-          expect(prev.registrationDate.getTime()).toBeLessThanOrEqual(
-            curr.registrationDate.getTime(),
+          expect(prev.registrationDate!.getTime()).toBeLessThanOrEqual(
+            curr.registrationDate!.getTime(),
           )
           return curr
         })
       })
       it('descending expiryDate', async () => {
         const expiryDateOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'expiryDate',
           orderDirection: 'desc',
-        })) as Registration[]
+        })) as Name[]
         expiryDateOrderedDesc.reduce((prev, curr) => {
-          expect(prev.expiryDate.getTime()).toBeGreaterThanOrEqual(
-            curr.expiryDate.getTime(),
+          expect(prev.expiryDate!.getTime()).toBeGreaterThanOrEqual(
+            curr.expiryDate!.getTime(),
           )
           return curr
         })
       })
       it('ascending expiryDate', async () => {
         const expiryDateOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'expiryDate',
           orderDirection: 'asc',
-        })) as Registration[]
+        })) as Name[]
         expiryDateOrderedAsc.reduce((prev, curr) => {
-          expect(prev.expiryDate.getTime()).toBeLessThanOrEqual(
-            curr.expiryDate.getTime(),
+          expect(prev.expiryDate!.getTime()).toBeLessThanOrEqual(
+            curr.expiryDate!.getTime(),
           )
           return curr
         })
       })
       it('descending labelName', async () => {
         const labelNameOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'labelName',
           orderDirection: 'desc',
-        })) as Registration[]
-        labelNameOrderedDesc.reduce((prev, curr) => {
-          expect((prev.labelName || '') > (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
+        })) as Name[]
+        expect(labelNameOrderedDesc.map((n) => n.labelName![0])).toStrictEqual(
+          letterItems,
+        )
       })
       it('ascending labelName', async () => {
         const labelNameOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'labelName',
           orderDirection: 'asc',
-        })) as Registration[]
-        labelNameOrderedAsc.reduce((prev, curr) => {
-          expect((prev.labelName || '') < (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
+        })) as Name[]
+        expect(labelNameOrderedAsc.map((n) => n.labelName![0])).toStrictEqual(
+          letterItems.reverse(),
+        )
       })
     })
     describe('owned names', () => {
       it('descending createdAt', async () => {
         const createdAtOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'owner',
           orderBy: 'createdAt',
           orderDirection: 'desc',
-        })) as OwnedName[]
+        })) as Name[]
         createdAtOrderedDesc.reduce((prev, curr) => {
-          expect(prev.createdAt.getTime()).toBeGreaterThanOrEqual(
-            curr.createdAt.getTime(),
+          expect(prev.createdAt!.getTime()).toBeGreaterThanOrEqual(
+            curr.createdAt!.getTime(),
           )
           return curr
         })
       })
       it('ascending createdAt', async () => {
         const createdAtOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'owner',
           orderBy: 'createdAt',
           orderDirection: 'asc',
-        })) as OwnedName[]
+        })) as Name[]
         createdAtOrderedAsc.reduce((prev, curr) => {
-          expect(prev.createdAt.getTime()).toBeLessThanOrEqual(
-            curr.createdAt.getTime(),
+          expect(prev.createdAt!.getTime()).toBeLessThanOrEqual(
+            curr.createdAt!.getTime(),
           )
           return curr
         })
       })
       it('descending labelName', async () => {
         const labelNameOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'owner',
           orderBy: 'labelName',
           orderDirection: 'desc',
-        })) as Registration[]
-        labelNameOrderedDesc.reduce((prev, curr) => {
-          if (
-            (!prev.labelName && !curr.labelName) ||
-            (!prev.labelName && curr.labelName)
-          )
-            return curr
-          expect((prev.labelName || '') > (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
+        })) as Name[]
+        expect(labelNameOrderedDesc.map((n) => n.name[0])).toStrictEqual(
+          domainLetterItems,
+        )
       })
       it('ascending labelName', async () => {
         const labelNameOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'owner',
           orderBy: 'labelName',
           orderDirection: 'asc',
-        })) as Registration[]
-        labelNameOrderedAsc.reduce((prev, curr) => {
-          if (
-            (!prev.labelName && !curr.labelName) ||
-            (prev.labelName && !curr.labelName)
-          )
-            return curr
-          expect((prev.labelName || '') < (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
+        })) as Name[]
+        expect(labelNameOrderedAsc.map((n) => n.name[0])).toStrictEqual(
+          domainLetterItems.reverse(),
+        )
       })
     })
   })

package/src/{tests → functions}/getOwner.test.ts

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
 let ENSInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -10,8 +10,6 @@ let accounts: string[]
 beforeAll(async () => {
   ;({ ENSInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
-  const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0])
-  await tx.wait()
 })
 
 afterAll(async () => {
@@ -24,38 +22,37 @@ describe('getOwner', () => {
     expect(result).toBeUndefined()
   })
   it('should return the owner, registrant, and ownership level for a registered name', async () => {
-    const result = await ENSInstance.getOwner('jefflau.eth')
+    const result = await ENSInstance.getOwner('with-profile.eth')
     expect(result).toMatchObject({
-      owner: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      registrant: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+      owner: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      registrant: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       ownershipLevel: 'registrar',
     })
   })
   it('should return nameWrapper as the ownership level for a wrapped name', async () => {
-    const result = await ENSInstance.getOwner('parthtejpal.eth')
+    const result = await ENSInstance.getOwner('wrapped.eth')
     expect(result?.ownershipLevel).toBe('nameWrapper')
   })
   it('should return the owner at a specific level if specified', async () => {
-    const result = await ENSInstance.getOwner('parthtejpal.eth', 'registrar')
+    const result = await ENSInstance.getOwner('wrapped.eth', 'registrar')
     const nameWrapperAddress = (await ENSInstance.contracts!.getNameWrapper())
       .address
     expect(result?.ownershipLevel).toBe('registrar')
     expect(result?.registrant).toBe(nameWrapperAddress)
   })
-  // 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])
-
-  //   const tx = await ENSInstance.createSubname({
-  //     name: 'test.fleek.eth',
-  //     contract: 'registry',
-  //     owner: accounts[0],
-  //     options: { addressOrIndex: accounts[1] },
-  //   })
-
-  //   await tx.wait()
-
-  //   const result = await ENSInstance.getOwner('test.fleek.eth')
-  //   expect(result?.ownershipLevel).toBe('registry')
-  // })
+  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 result = await ENSInstance.getOwner('test.with-subnames.eth')
+    expect(result?.ownershipLevel).toBe('registry')
+    expect(result?.owner).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
+  })
 })

package/src/functions/getOwner.ts

@@ -1,6 +1,7 @@
 import { ethers } from 'ethers'
 import { ENSArgs } from '..'
 import { labelhash } from '../utils/labels'
+import { namehash as makeNamehash } from '../utils/normalise'
 
 type Owner = {
   registrant?: string
@@ -49,13 +50,13 @@ const raw = async (
   name: string,
   contract?: 'nameWrapper' | 'registry' | 'registrar',
 ) => {
-  const namehash = ethers.utils.namehash(name)
+  const namehash = makeNamehash(name)
   const labels = name.split('.')
 
-  if (contract) {
+  if (contract || labels.length === 1) {
     return await singleContractOwnerRaw(
       { contracts },
-      contract,
+      contract || 'registry',
       namehash,
       labels,
     )
@@ -99,10 +100,11 @@ const decode = async (
   contract?: 'nameWrapper' | 'registry' | 'registrar',
 ): Promise<Owner | undefined> => {
   if (data === null) return
-  if (contract) {
+  const labels = name.split('.')
+  if (contract || labels.length === 1) {
     const singleOwner = singleContractOwnerDecode(data)
     let obj = {
-      ownershipLevel: contract,
+      ownershipLevel: contract || 'registry',
     }
     if (contract === 'registrar') {
       return {
@@ -133,8 +135,6 @@ const decode = async (
     decodedData[2] as ethers.utils.Result | undefined
   )?.[0]
 
-  const labels = name.split('.')
-
   // check for only .eth names
   if (labels[labels.length - 1] === 'eth') {
     // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner

package/src/functions/getProfile.test.ts

@@ -0,0 +1,143 @@
+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, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+const checkRecords = (
+  result: Record<string, any> | undefined,
+  textLength = 3,
+  coinTypeLength = 3,
+) => {
+  expect(result).toBeDefined()
+  if (result) {
+    expect(result.records?.texts).toHaveLength(textLength)
+    expect(result.records?.coinTypes).toHaveLength(coinTypeLength)
+    expect(result.resolverAddress).toBe(
+      '0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8',
+    )
+  }
+}
+
+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(
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      )
+      expect(result).toBeDefined()
+      if (result) {
+        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(
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+        { texts: ['description', 'url'], coinTypes: ['ETC', '0'] },
+      )
+      expect(result).toBeDefined()
+      if (result) {
+        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(
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+        { texts: true, coinTypes: true },
+      )
+      checkRecords(result)
+    })
+    it('should return null for an address without a name', async () => {
+      const result = await ENSInstance.getProfile(
+        '0x8e8db5ccef88cca9d624701db544989c996e3216',
+      )
+      expect(result).toBeUndefined()
+    })
+  })
+  describe('with a name', () => {
+    it('should return a profile object with no other args', async () => {
+      const result = await ENSInstance.getProfile('with-profile.eth')
+      expect((result as any).address).toBe(
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      )
+      checkRecords(result)
+    })
+    it('should return a profile object with specified records', async () => {
+      const result = await ENSInstance.getProfile('with-profile.eth', {
+        texts: ['description', 'url'],
+        coinTypes: ['ETC', '0'],
+      })
+      expect((result as any).address).toBe(
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      )
+      checkRecords(result, 2, 3)
+    })
+    it('should return a profile object with all of each specified record type', async () => {
+      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 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(accounts[1])
+      expect(result?.resolverAddress).toBe(
+        '0x1613beB3B2C4f22Ee086B2b38C1476A3cE7f78E8',
+      )
+    })
+    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('with-legacy-resolver.eth')
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBe(
+          '0x70997970C51812dc3A010C7d01b50e0d17dc79C8',
+        )
+        expect(result.resolverAddress).toBe(
+          '0x5f3f1dbd7b74c6b46e8c44f98792a1daf8d69154',
+        )
+      }
+    })
+  })
+  describe('with an unmigrated name', () => {
+    it('should return an object with isMigrated false and a message', async () => {
+      const result = await ENSInstance.getProfile('legacy.test')
+      expect(result).toBeTruthy()
+      if (result) {
+        expect(result.isMigrated).toBe(false)
+      }
+    })
+  })
+})