@ensdomains/ensjs 3.0.0-alpha.4 → 3.0.0-alpha.41

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 () => {
@@ -19,53 +13,8 @@ afterAll(async () => {
 })
 
 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('jefflau.eth')
-    expect(result).toMatchObject({
-      owner: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      registrant: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
-      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())
-      .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 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')
-  // })
 })

package/src/functions/getOwner.ts

@@ -1,4 +1,6 @@
-import { ethers } from 'ethers'
+import { defaultAbiCoder } from '@ethersproject/abi/lib/abi-coder'
+import type { Result } from '@ethersproject/abi/lib/coders/abstract-coder'
+import { hexStripZeros } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { labelhash } from '../utils/labels'
 import { namehash as makeNamehash } from '../utils/normalise'
@@ -42,6 +44,7 @@ const singleContractOwnerRaw = async (
         ]),
       }
     }
+    // no default
   }
 }
 
@@ -54,7 +57,7 @@ const raw = async (
   const labels = name.split('.')
 
   if (contract || labels.length === 1) {
-    return await singleContractOwnerRaw(
+    return singleContractOwnerRaw(
       { contracts },
       contract || 'registry',
       namehash,
@@ -83,27 +86,43 @@ 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)
   }
 
   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,32 +130,36 @@ 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
-  )?.[0]
+  const registryOwner = (decodedData[0] as Result)[0]
+  const nameWrapperOwner = (decodedData[1] as Result)[0]
+  let registrarOwner = (decodedData[2] as Result | undefined)?.[0]
 
   // check for only .eth names
   if (labels[labels.length - 1] === 'eth') {
+    if (!registrarOwner && labels.length === 2) {
+      const graphRegistrantResult = await gqlInstance.client.request(
+        registrantQuery,
+        {
+          namehash: makeNamehash(name),
+        },
+      )
+      registrarOwner =
+        graphRegistrantResult.domain?.registration?.registrant?.id
+    }
     // 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) {
@@ -156,12 +179,22 @@ const decode = async (
         ownershipLevel: 'registrar',
       }
     }
-    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',
+        }
+      }
       // 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 +214,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 +226,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/lib/abi-coder'
+import { BigNumber } from '@ethersproject/bignumber/lib/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-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')
+    }
+  })
+})