@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.61

package/src/functions/getOwner.ts

@@ -1,12 +1,16 @@
-import { ethers } from 'ethers'
+import type { Result } from '@ethersproject/abi'
+import { defaultAbiCoder } from '@ethersproject/abi'
+import { hexStripZeros } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { labelhash } from '../utils/labels'
 import { namehash as makeNamehash } from '../utils/normalise'
+import { checkIsDotEth } from '../utils/validation'
 
 type Owner = {
   registrant?: string
   owner?: string
   ownershipLevel: 'nameWrapper' | 'registry' | 'registrar'
+  expired?: boolean
 }
 
 const singleContractOwnerRaw = async (
@@ -42,6 +46,7 @@ const singleContractOwnerRaw = async (
         ]),
       }
     }
+    // no default
   }
 }
 
@@ -54,7 +59,7 @@ const raw = async (
   const labels = name.split('.')
 
   if (contract || labels.length === 1) {
-    return await singleContractOwnerRaw(
+    return singleContractOwnerRaw(
       { contracts },
       contract || 'registry',
       namehash,
@@ -83,27 +88,43 @@ const raw = async (
 
   const data: { to: string; data: string }[] = [registryData, nameWrapperData]
 
-  if (labels.length == 2 && labels[1] === 'eth') {
+  if (checkIsDotEth(labels)) {
     data.push(registrarData)
   }
 
   return multicallWrapper.raw(data)
 }
 
+const registrantQuery = `
+  query GetRegistrant($namehash: String!) {
+    domain(id: $namehash) {
+      registration {
+        registrant {
+          id
+        }
+      }
+    }
+  }
+`
+
 const singleContractOwnerDecode = (data: string) =>
-  ethers.utils.defaultAbiCoder.decode(['address'], data)[0]
+  defaultAbiCoder.decode(['address'], data)[0]
 
 const decode = async (
-  { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
+  {
+    contracts,
+    multicallWrapper,
+    gqlInstance,
+  }: ENSArgs<'contracts' | 'multicallWrapper' | 'gqlInstance'>,
   data: string,
   name: string,
   contract?: 'nameWrapper' | 'registry' | 'registrar',
 ): Promise<Owner | undefined> => {
-  if (data === null) return
+  if (!data) return
   const labels = name.split('.')
   if (contract || labels.length === 1) {
     const singleOwner = singleContractOwnerDecode(data)
-    let obj = {
+    const obj = {
       ownershipLevel: contract || 'registry',
     }
     if (contract === 'registrar') {
@@ -111,38 +132,59 @@ 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)
-  if (result === null) return
+  if (!result) return
   const nameWrapper = await contracts?.getNameWrapper()!
 
   const decodedData = [result[0][1], result[1][1], result[2]?.[1]].map(
-    (ret) =>
-      ret &&
-      ret !== '0x' &&
-      ethers.utils.defaultAbiCoder.decode(['address'], ret),
+    (ret) => ret && ret !== '0x' && defaultAbiCoder.decode(['address'], ret),
   )
 
-  const registryOwner = (decodedData[0] as ethers.utils.Result)[0]
-  const nameWrapperOwner = (decodedData[1] as ethers.utils.Result)[0]
-  const registrarOwner = (
-    decodedData[2] as ethers.utils.Result | undefined
+  const registryOwner = (decodedData[0] as Result)[0]
+  const nameWrapperOwner = (decodedData[1] as Result)[0]
+  let registrarOwner: string | undefined = (
+    decodedData[2] as Result | undefined
   )?.[0]
+  let baseReturnObject: {
+    expired?: boolean
+  } = {}
 
   // check for only .eth names
   if (labels[labels.length - 1] === 'eth') {
+    // if there is no registrar owner, the name is expired
+    // but we still want to get the registrar owner prior to expiry
+    if (labels.length === 2) {
+      if (!registrarOwner) {
+        const graphRegistrantResult = await gqlInstance.client.request(
+          registrantQuery,
+          {
+            namehash: makeNamehash(name),
+          },
+        )
+        registrarOwner =
+          graphRegistrantResult.domain?.registration?.registrant?.id
+        baseReturnObject = {
+          expired: true,
+        }
+      } else {
+        baseReturnObject = {
+          expired: false,
+        }
+      }
+    }
     // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner
     // there is no "registrant" for wrapped names
-    if (registrarOwner === nameWrapper.address) {
+    if (registrarOwner?.toLowerCase() === nameWrapper.address.toLowerCase()) {
       return {
         owner: nameWrapperOwner,
         ownershipLevel: 'nameWrapper',
+        ...baseReturnObject,
       }
     }
     // if there is a registrar owner, then it's not a subdomain but we have also passed the namewrapper clause
@@ -154,14 +196,26 @@ const decode = async (
         registrant: registrarOwner,
         owner: registryOwner,
         ownershipLevel: 'registrar',
+        ...baseReturnObject,
       }
     }
-    if (
-      labels.length > 2 &&
-      ethers.utils.hexStripZeros(registryOwner) !== '0x'
-    ) {
+    if (hexStripZeros(registryOwner) !== '0x') {
+      // if there is no registrar owner, but the label length is two, then the domain is an expired 2LD .eth
+      // so we still want to return the ownership values
+      if (labels.length === 2) {
+        return {
+          registrant: undefined,
+          owner: registryOwner,
+          ownershipLevel: 'registrar',
+          expired: true,
+        }
+      }
       // this means that the subname is wrapped
-      if (registryOwner === nameWrapper.address) {
+      if (
+        registryOwner === nameWrapper.address &&
+        nameWrapperOwner &&
+        hexStripZeros(nameWrapperOwner) !== '0x'
+      ) {
         return {
           owner: nameWrapperOwner,
           ownershipLevel: 'nameWrapper',
@@ -181,7 +235,11 @@ 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 &&
+    nameWrapperOwner &&
+    hexStripZeros(nameWrapperOwner) !== '0x'
+  ) {
     return {
       owner: nameWrapperOwner,
       ownershipLevel: 'nameWrapper',
@@ -189,7 +247,7 @@ const decode = async (
   }
 
   // for unwrapped non .eth names, the owner is the registry owner
-  if (ethers.utils.hexStripZeros(registryOwner) !== '0x') {
+  if (hexStripZeros(registryOwner) !== '0x') {
     return {
       owner: registryOwner,
       ownershipLevel: 'registry',

package/src/functions/getPrice.test.ts

@@ -0,0 +1,55 @@
+import { BigNumber } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup())
+})
+
+const yearCost = BigNumber.from('8561643835626')
+
+describe('getPrice', () => {
+  it('should return a base and premium price for a name', async () => {
+    const { base, premium } = (await ensInstance.getPrice(
+      'test123',
+      86400,
+      false,
+    ))!
+    expect(base.eq(yearCost)).toBe(true)
+    expect(premium.toNumber()).toBe(0)
+  })
+
+  it('should return a base and premium price for an array of names', async () => {
+    const { base, premium } = (await ensInstance.getPrice(
+      ['test123', 'to-be-renewed'],
+      86400,
+      false,
+    ))!
+    expect(base.eq(yearCost.mul(2))).toBe(true)
+    expect(premium.toNumber()).toBe(0)
+  })
+
+  describe('legacy mode', () => {
+    it('should return a base and premium price for a name', async () => {
+      const { base, premium } = (await ensInstance.getPrice(
+        'test123',
+        86400,
+        true,
+      ))!
+      expect(base.eq(yearCost)).toBe(true)
+      expect(premium.toNumber()).toBe(0)
+    })
+
+    it('should return a base and premium price for an array of names', async () => {
+      const { base, premium } = (await ensInstance.getPrice(
+        ['test123', 'to-be-renewed'],
+        86400,
+        true,
+      ))!
+      expect(base.eq(yearCost.mul(2))).toBe(true)
+      expect(premium.toNumber()).toBe(0)
+    })
+  })
+})

package/src/functions/getPrice.ts

@@ -1,18 +1,47 @@
-import { BigNumber, utils } from 'ethers'
+import { defaultAbiCoder } from '@ethersproject/abi'
+import { BigNumber } from '@ethersproject/bignumber'
 import { ENSArgs } from '..'
 
 const raw = async (
   { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
-  name: string,
+  nameOrNames: string | string[],
   duration: number,
   legacy?: boolean,
 ) => {
+  const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames]
+
+  if (names.length > 1) {
+    const bulkRenewal = await contracts?.getBulkRenewal()!
+    const baseCall = {
+      to: bulkRenewal.address,
+      data: bulkRenewal.interface.encodeFunctionData('rentPrice', [
+        names,
+        duration,
+      ]),
+    }
+
+    if (legacy) {
+      return multicallWrapper.raw([
+        baseCall,
+        {
+          to: bulkRenewal.address,
+          data: bulkRenewal.interface.encodeFunctionData('rentPrice', [
+            names,
+            0,
+          ]),
+        },
+      ])
+    }
+
+    return baseCall
+  }
+
   const controller = await contracts?.getEthRegistrarController()!
 
   const baseCall = {
     to: controller.address,
     data: controller.interface.encodeFunctionData('rentPrice', [
-      name,
+      names[0],
       duration,
     ]),
   }
@@ -22,42 +51,66 @@ const raw = async (
       baseCall,
       {
         to: controller.address,
-        data: controller.interface.encodeFunctionData('rentPrice', [name, 0]),
+        data: controller.interface.encodeFunctionData('rentPrice', [
+          names[0],
+          0,
+        ]),
       },
     ])
   }
-
   return baseCall
 }
 
 const decode = async (
   { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
   data: string,
-  _name: string,
-  _number: number,
+  _nameOrNames: string | string[],
+  _duration: number,
   legacy?: boolean,
 ) => {
   if (data === null) return
-  const controller = await contracts?.getEthRegistrarController()!
   try {
     let base: BigNumber
     let premium: BigNumber
-    if (legacy) {
+
+    const isBulkRenewal = Array.isArray(_nameOrNames) && _nameOrNames.length > 1
+    if (isBulkRenewal && legacy) {
+      const result = await multicallWrapper.decode(data)
+      const [price] = defaultAbiCoder.decode(
+        ['uint256'],
+        result[0].returnData,
+      ) as [BigNumber]
+      ;[premium] = defaultAbiCoder.decode(
+        ['uint256'],
+        result[1].returnData,
+      ) as [BigNumber]
+      base = price.sub(premium)
+    } else if (isBulkRenewal) {
+      const bulkRenewal = await contracts?.getBulkRenewal()!
+      const result = bulkRenewal.interface.decodeFunctionResult(
+        'rentPrice',
+        data,
+      )
+      ;[base] = result
+      premium = BigNumber.from(0)
+    } else if (!isBulkRenewal && legacy) {
       const result = await multicallWrapper.decode(data)
-      const [price] = utils.defaultAbiCoder.decode(
+      const [price] = defaultAbiCoder.decode(
         ['uint256'],
         result[0].returnData,
       ) as [BigNumber]
-      ;[premium] = utils.defaultAbiCoder.decode(
+      ;[premium] = defaultAbiCoder.decode(
         ['uint256'],
         result[1].returnData,
       ) as [BigNumber]
       base = price.sub(premium)
     } else {
-      ;[base, premium] = controller.interface.decodeFunctionData(
+      const controller = await contracts?.getEthRegistrarController()!
+      const result = controller.interface.decodeFunctionResult(
         'rentPrice',
         data,
-      ) as [BigNumber, BigNumber]
+      )
+      ;[base, premium] = result[0] as [BigNumber, BigNumber]
     }
     return {
       base,

package/src/functions/getProfile.test.ts

@@ -1,23 +1,39 @@
+import dotenv from 'dotenv'
+import { ethers } from 'ethers'
 import { ENS } from '..'
-import setup from '../tests/setup'
+import setup, { deploymentAddresses } from '../tests/setup'
 
-let ENSInstance: ENS
+dotenv.config()
+
+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()
+})
+
+beforeEach(async () => {
+  await revert()
+})
+
+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',
+      deploymentAddresses.LegacyPublicResolver,
     )
   }
 }
@@ -27,37 +43,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',
-        { texts: ['description', 'url'], coinTypes: ['ETC', '0'] },
+      const result = await ensInstance.getProfile(
+        '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+        { texts: ['description', 'url'], coinTypes: ['ETC_LEGACY', '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,56 +81,146 @@ 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'],
+        coinTypes: ['ETC_LEGACY', '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: deploymentAddresses.LegacyPublicResolver,
+      })
+      expect(result).toBeDefined()
+      expect(result?.address).toBe(accounts[1])
+      expect(result?.resolverAddress).toBe(
+        deploymentAddresses.LegacyPublicResolver,
+      )
+    })
+    it('should return the decoded name for a name with encoded labels', async () => {
+      const result = await ensInstance.getProfile(
+        '[9dd2c369a187b4e6b9c402f030e50743e619301ea62aa4c0737d4ef7e10a3d49].with-subnames.eth',
+      )
+      expect(result).toBeDefined()
+      expect(result?.decryptedName).toBe('xyz.with-subnames.eth')
+    })
     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(
+          deploymentAddresses.NoMulticallResolver,
         )
       }
     })
   })
   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)
       }
     })
   })
+  describe('with invalid resolver', () => {
+    it('should fail gracefully for a name with invalid resolver', async () => {
+      const tx = await ensInstance.setResolver('test123.eth', {
+        contract: 'registry',
+        resolver: '0xb794F5eA0ba39494cE839613fffBA74279579268',
+        addressOrIndex: 1,
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+      const result = await ensInstance.getProfile('test123.eth')
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBeUndefined()
+        expect(Object.keys(result.records!).length).toBe(0)
+        expect(result.resolverAddress).toBe(
+          '0xb794F5eA0ba39494cE839613fffBA74279579268',
+        )
+        expect(result.isInvalidResolverAddress).toBe(true)
+      }
+    })
+
+    it('should fail gracefully for a wrapped name with invalid resolver', async () => {
+      const tx = await ensInstance.setResolver('wrapped.eth', {
+        contract: 'nameWrapper',
+        resolver: '0xb794F5eA0ba39494cE839613fffBA74279579268',
+        addressOrIndex: 1,
+      })
+      expect(tx).toBeTruthy()
+      await tx.wait()
+      const result = await ensInstance.getProfile('wrapped.eth')
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBeUndefined()
+        expect(Object.keys(result.records!).length).toBe(0)
+        expect(result.resolverAddress).toBe(
+          '0xb794F5eA0ba39494cE839613fffBA74279579268',
+        )
+        expect(result.isInvalidResolverAddress).toBe(true)
+      }
+    })
+
+    it('should fail gracefully for name with invalid resolver option', async () => {
+      const result = await ensInstance.getProfile('test123.eth', {
+        resolverAddress: '0xb794F5eA0ba39494cE839613fffBA74279579268',
+      })
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBeFalsy()
+        expect(Object.keys(result.records!).length).toBe(0)
+        expect(result.resolverAddress).toBe(
+          '0xb794F5eA0ba39494cE839613fffBA74279579268',
+        )
+      }
+    })
+
+    it('should fail gracefully for wrapped name with invalid resolver option', async () => {
+      const result = await ensInstance.getProfile('wrapped.eth', {
+        resolverAddress: '0xb794F5eA0ba39494cE839613fffBA74279579268',
+      })
+      expect(result).toBeDefined()
+      if (result) {
+        expect(result.address).toBeFalsy()
+        expect(Object.keys(result.records!).length).toBe(0)
+        expect(result.resolverAddress).toBe(
+          '0xb794F5eA0ba39494cE839613fffBA74279579268',
+        )
+      }
+    })
+  })
 })