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

package/src/functions/getNames.ts

@@ -175,9 +175,8 @@ const getNames = async (
         orderDirection,
       }
     }
-  } else {
-    if (typeof page !== 'number') {
-      finalQuery = gqlInstance.gql`
+  } else if (typeof page !== 'number') {
+    finalQuery = gqlInstance.gql`
         query getNames(
           $id: ID!
           $orderBy: Registration_orderBy
@@ -200,14 +199,14 @@ const getNames = async (
         }
       `
 
-      queryVars = {
-        id: address,
-        orderBy,
-        orderDirection,
-        expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
-      }
-    } else {
-      finalQuery = gqlInstance.gql`
+    queryVars = {
+      id: address,
+      orderBy,
+      orderDirection,
+      expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
+    }
+  } else {
+    finalQuery = gqlInstance.gql`
         query getNames(
           $id: ID!
           $first: Int
@@ -234,14 +233,13 @@ const getNames = async (
         }
       `
 
-      queryVars = {
-        id: address,
-        first: pageSize,
-        skip: (page || 0) * pageSize,
-        orderBy: orderBy,
-        orderDirection: orderDirection,
-        expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
-      }
+    queryVars = {
+      id: address,
+      first: pageSize,
+      skip: (page || 0) * pageSize,
+      orderBy,
+      orderDirection,
+      expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
     }
   }
 
@@ -254,22 +252,19 @@ const getNames = async (
       if (orderDirection === 'desc') {
         if (orderBy === 'labelName') {
           return b.name.localeCompare(a.name)
-        } else {
-          return b.createdAt.getTime() - a.createdAt.getTime()
-        }
-      } else {
-        if (orderBy === 'labelName') {
-          return a.name.localeCompare(b.name)
-        } else if (orderBy === 'creationDate') {
-          return a.createdAt.getTime() - b.createdAt.getTime()
         }
+        return b.createdAt.getTime() - a.createdAt.getTime()
+      }
+      if (orderBy === 'labelName') {
+        return a.name.localeCompare(b.name)
       }
+      return a.createdAt.getTime() - b.createdAt.getTime()
     }) as Name[]
-  } else if (type === 'owner') {
+  }
+  if (type === 'owner') {
     return account.domains.map(mapDomain) as Name[]
-  } else {
-    return account.registrations.map(mapRegistration) as Name[]
   }
+  return account.registrations.map(mapRegistration) as Name[]
 }
 
 export default getNames

package/src/functions/getOwner.test.ts

@@ -0,0 +1,67 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ensInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('getOwner', () => {
+  it('should return null for an unregistered name', async () => {
+    const result = await ensInstance.getOwner('test123123cool.eth')
+    expect(result).toBeUndefined()
+  })
+  it('should return the owner, registrant, and ownership level for a registered name', async () => {
+    const result = await ensInstance.getOwner('with-profile.eth')
+    expect(result).toMatchObject({
+      owner: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      registrant: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      ownershipLevel: 'registrar',
+    })
+  })
+  it('should return nameWrapper as the ownership level for a wrapped name', async () => {
+    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('wrapped.eth', 'registrar')
+    const nameWrapperAddress = (await ensInstance.contracts!.getNameWrapper())
+      .address
+    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 result = await ensInstance.getOwner('test.with-subnames.eth')
+    expect(result?.ownershipLevel).toBe('registry')
+    expect(result?.owner).toBe('0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC')
+  })
+  it('should return registry ownership for a pseudo-wrapped name', async () => {
+    const nameWrapper = await ensInstance.contracts!.getNameWrapper()
+    const tx = await ensInstance.transferSubname('test.with-subnames.eth', {
+      contract: 'registry',
+      owner: nameWrapper.address,
+      addressOrIndex: 1,
+    })
+    await tx.wait()
+
+    const result = await ensInstance.getOwner('test.with-subnames.eth')
+    expect(result?.ownershipLevel).toBe('registry')
+    expect(result?.owner).toBe(nameWrapper.address)
+  })
+})

package/src/functions/getOwner.ts

@@ -42,6 +42,7 @@ const singleContractOwnerRaw = async (
         ]),
       }
     }
+    // no default
   }
 }
 
@@ -54,7 +55,7 @@ const raw = async (
   const labels = name.split('.')
 
   if (contract || labels.length === 1) {
-    return await singleContractOwnerRaw(
+    return singleContractOwnerRaw(
       { contracts },
       contract || 'registry',
       namehash,
@@ -83,7 +84,7 @@ const raw = async (
 
   const data: { to: string; data: string }[] = [registryData, nameWrapperData]
 
-  if (labels.length == 2 && labels[1] === 'eth') {
+  if (labels.length === 2 && labels[1] === 'eth') {
     data.push(registrarData)
   }
 
@@ -103,7 +104,7 @@ const decode = async (
   const labels = name.split('.')
   if (contract || labels.length === 1) {
     const singleOwner = singleContractOwnerDecode(data)
-    let obj = {
+    const obj = {
       ownershipLevel: contract || 'registry',
     }
     if (contract === 'registrar') {
@@ -111,11 +112,10 @@ const decode = async (
         ...obj,
         registrant: singleOwner as string,
       }
-    } else {
-      return {
-        ...obj,
-        owner: singleOwner as string,
-      }
+    }
+    return {
+      ...obj,
+      owner: singleOwner as string,
     }
   }
   const result = await multicallWrapper.decode(data)
@@ -161,7 +161,10 @@ const decode = async (
       ethers.utils.hexStripZeros(registryOwner) !== '0x'
     ) {
       // this means that the subname is wrapped
-      if (registryOwner === nameWrapper.address) {
+      if (
+        registryOwner === nameWrapper.address &&
+        ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x'
+      ) {
         return {
           owner: nameWrapperOwner,
           ownershipLevel: 'nameWrapper',
@@ -181,7 +184,10 @@ const decode = async (
   // there will only ever be an owner for non .eth names, not a registrant
   // this is because for unwrapped names, there is no associated NFT
   // and for wrapped names, owner and registrant are the same thing
-  if (registryOwner == nameWrapper.address) {
+  if (
+    registryOwner === nameWrapper.address &&
+    ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x'
+  ) {
     return {
       owner: nameWrapperOwner,
       ownershipLevel: 'nameWrapper',

package/src/functions/getPrice.ts

@@ -54,10 +54,10 @@ const decode = async (
       ) as [BigNumber]
       base = price.sub(premium)
     } else {
-      ;[base, premium] = controller.interface.decodeFunctionData(
+      ;[[base, premium]] = controller.interface.decodeFunctionResult(
         'rentPrice',
         data,
-      ) as [BigNumber, BigNumber]
+      )
     }
     return {
       base,

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

@@ -1,23 +1,32 @@
+import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from './setup'
+import setup from '../tests/setup'
 
-let ENSInstance: ENS
+let ensInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+let provider: ethers.providers.JsonRpcProvider
+let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ensInstance, revert, provider } = await setup())
+  accounts = await provider.listAccounts()
+})
+
+afterAll(async () => {
+  await revert()
 })
 
 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',
     )
   }
 }
@@ -27,37 +36,37 @@ 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',
+      const result = await ensInstance.getProfile(
+        '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',
+      const result = await ensInstance.getProfile(
+        '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',
+      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(
+      const result = await ensInstance.getProfile(
         '0x8e8db5ccef88cca9d624701db544989c996e3216',
       )
       expect(result).toBeUndefined()
@@ -65,52 +74,66 @@ 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 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')
+      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')
+      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)