@ensdomains/ensjs 3.0.0-alpha.3 → 3.0.0-alpha.30

package/src/functions/getOwner.test.ts

@@ -1,17 +1,11 @@
-import { ethers } from 'ethers'
 import { ENS } from '..'
 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, revert, provider } = await setup())
-  accounts = await provider.listAccounts()
-  const tx = await ENSInstance.wrapName('parthtejpal.eth', accounts[0])
-  await tx.wait()
+  ;({ ensInstance, revert } = await setup())
 })
 
 afterAll(async () => {
@@ -20,52 +14,54 @@ afterAll(async () => {
 
 describe('getOwner', () => {
   it('should return null for an unregistered name', async () => {
-    const result = await ENSInstance.getOwner('test123123cool.eth')
+    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('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 nameWrapperAddress = (await ENSInstance.contracts!.getNameWrapper())
+    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 result = await ensInstance.getOwner('eth')
     const baseRegistrarAddress = (
-      await ENSInstance.contracts!.getBaseRegistrar()
+      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])
-
-  //   const tx = await ENSInstance.createSubname({
-  //     name: 'test.fleek.eth',
-  //     contract: 'registry',
-  //     owner: accounts[0],
-  //     options: { addressOrIndex: accounts[1] },
-  //   })
-
-  //   await tx.wait()
+  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.fleek.eth')
-  //   expect(result?.ownershipLevel).toBe('registry')
-  // })
+    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)
   }
 
@@ -99,11 +100,11 @@ const decode = async (
   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,15 +112,14 @@ 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(
@@ -161,7 +161,11 @@ const decode = async (
       ethers.utils.hexStripZeros(registryOwner) !== '0x'
     ) {
       // this means that the subname is wrapped
-      if (registryOwner === nameWrapper.address) {
+      if (
+        registryOwner === nameWrapper.address &&
+        nameWrapperOwner &&
+        ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x'
+      ) {
         return {
           owner: nameWrapperOwner,
           ownershipLevel: 'nameWrapper',
@@ -181,7 +185,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 &&
+    ethers.utils.hexStripZeros(nameWrapperOwner) !== '0x'
+  ) {
     return {
       owner: nameWrapperOwner,
       ownershipLevel: 'nameWrapper',

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

@@ -3,16 +3,44 @@ 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,27 +50,49 @@ 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] = utils.defaultAbiCoder.decode(
+        ['uint256'],
+        result[0].returnData,
+      ) as [BigNumber]
+      ;[premium] = utils.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(
         ['uint256'],
@@ -54,10 +104,12 @@ const decode = async (
       ) 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-ccip.test.ts

@@ -0,0 +1,29 @@
+import dotenv from 'dotenv'
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+dotenv.config()
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup(true))
+})
+
+jest.setTimeout(20000)
+
+describe('getProfile', () => {
+  it('should return a profile from a ccip-read name', async () => {
+    const result = await ensInstance.getProfile('1.offchainexample.eth', {
+      fallback: {
+        texts: ['email', 'description'],
+        contentHash: true,
+        coinTypes: ['0', '60'],
+      },
+    })
+    expect(result).toBeTruthy()
+    if (result) {
+      expect(result.address).toBe('0x41563129cDbbD0c5D3e1c86cf9563926b243834d')
+    }
+  })
+})

package/src/functions/getProfile.test.ts

@@ -1,23 +1,35 @@
+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()
+})
+
+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 +39,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 +77,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: deploymentAddresses.LegacyPublicResolver,
+      })
+      expect(result).toBeDefined()
+      expect(result?.address).toBe(accounts[1])
+      expect(result?.resolverAddress).toBe(
+        deploymentAddresses.LegacyPublicResolver,
+      )
+    })
     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)