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

package/src/functions/getNames.test.ts

@@ -0,0 +1,285 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { Name } from './getNames'
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup())
+})
+
+const testProperties = (obj: object, ...properties: string[]) =>
+  properties.map((property) => expect(obj).toHaveProperty(property))
+
+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 = [
+  '[',
+  'x',
+  'w',
+  't',
+  't',
+  'l',
+  'a',
+  '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: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'registrant',
+    })
+    totalRegistrations = result.length
+    expect(result).toBeTruthy()
+    testProperties(
+      result[0],
+      'expiryDate',
+      'registrationDate',
+      'id',
+      'labelName',
+      'labelhash',
+      'name',
+      'isMigrated',
+      'parent',
+      'truncatedName',
+    )
+  })
+  it('should get the owned names for an address', async () => {
+    const result = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'owner',
+    })
+    totalOwnedNames = result.length
+    expect(result).toBeTruthy()
+    testProperties(
+      result[0],
+      'id',
+      'labelName',
+      'labelhash',
+      'name',
+      'isMigrated',
+      'parent',
+      'truncatedName',
+    )
+    testNotProperties(result[0], 'expiryDate', 'registrationDate')
+  })
+  it('should get the registrations for an address with pagination', async () => {
+    const pageOne = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'registrant',
+      page: 0,
+    })
+    expect(pageOne).toHaveLength(10)
+    const pageTwo = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'registrant',
+      page: 1,
+    })
+    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: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'owner',
+      page: 0,
+    })
+    expect(pageOne).toHaveLength(10)
+    const pageTwo = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'owner',
+      page: 1,
+    })
+    expect(pageTwo).toHaveLength(10)
+    const pageThree = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'owner',
+      page: 2,
+    })
+    expect(pageThree).toHaveLength(10)
+    const pageFour = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'owner',
+      page: 3,
+    })
+    expect(pageFour).toHaveLength(10)
+    const pageFive = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'owner',
+      page: 4,
+    })
+    expect(pageFive).toHaveLength(totalOwnedNames % 10)
+  })
+  describe('orderBy', () => {
+    describe('registrations', () => {
+      it('descending registrationDate', async () => {
+        const registrationDateOrderedDesc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          type: 'registrant',
+          orderBy: 'registrationDate',
+          orderDirection: 'desc',
+        })) as Name[]
+        registrationDateOrderedDesc.reduce((prev, curr) => {
+          expect(prev.registrationDate!.getTime()).toBeGreaterThanOrEqual(
+            curr.registrationDate!.getTime(),
+          )
+          return curr
+        })
+      })
+      it('ascending registrationDate', async () => {
+        const registrationDateOrderedAsc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          type: 'registrant',
+          orderBy: 'registrationDate',
+          orderDirection: 'asc',
+        })) as Name[]
+        registrationDateOrderedAsc.reduce((prev, curr) => {
+          expect(prev.registrationDate!.getTime()).toBeLessThanOrEqual(
+            curr.registrationDate!.getTime(),
+          )
+          return curr
+        })
+      })
+      it('descending expiryDate', async () => {
+        const expiryDateOrderedDesc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          type: 'registrant',
+          orderBy: 'expiryDate',
+          orderDirection: 'desc',
+        })) as Name[]
+        expiryDateOrderedDesc.reduce((prev, curr) => {
+          expect(prev.expiryDate!.getTime()).toBeGreaterThanOrEqual(
+            curr.expiryDate!.getTime(),
+          )
+          return curr
+        })
+      })
+      it('ascending expiryDate', async () => {
+        const expiryDateOrderedAsc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          type: 'registrant',
+          orderBy: 'expiryDate',
+          orderDirection: 'asc',
+        })) as Name[]
+        expiryDateOrderedAsc.reduce((prev, curr) => {
+          expect(prev.expiryDate!.getTime()).toBeLessThanOrEqual(
+            curr.expiryDate!.getTime(),
+          )
+          return curr
+        })
+      })
+      it('descending labelName', async () => {
+        const labelNameOrderedDesc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          type: 'registrant',
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+        })) as Name[]
+        expect(labelNameOrderedDesc.map((n) => n.labelName![0])).toStrictEqual(
+          letterItems,
+        )
+      })
+      it('ascending labelName', async () => {
+        const labelNameOrderedAsc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          type: 'registrant',
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+        })) 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: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          type: 'owner',
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+        })) as Name[]
+        createdAtOrderedDesc.reduce((prev, curr) => {
+          expect(prev.createdAt!.getTime()).toBeGreaterThanOrEqual(
+            curr.createdAt!.getTime(),
+          )
+          return curr
+        })
+      })
+      it('ascending createdAt', async () => {
+        const createdAtOrderedAsc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          type: 'owner',
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+        })) as Name[]
+        createdAtOrderedAsc.reduce((prev, curr) => {
+          expect(prev.createdAt!.getTime()).toBeLessThanOrEqual(
+            curr.createdAt!.getTime(),
+          )
+          return curr
+        })
+      })
+      it('descending labelName', async () => {
+        const labelNameOrderedDesc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          type: 'owner',
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+        })) as Name[]
+        expect(labelNameOrderedDesc.map((n) => n.name[0])).toStrictEqual(
+          domainLetterItems,
+        )
+      })
+      it('ascending labelName', async () => {
+        const labelNameOrderedAsc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          type: 'owner',
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+        })) as Name[]
+        expect(labelNameOrderedAsc.map((n) => n.name[0])).toStrictEqual(
+          domainLetterItems.reverse(),
+        )
+      })
+    })
+  })
+})

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.test.ts

@@ -0,0 +1,52 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+let ensInstance: ENS
+
+beforeAll(async () => {
+  ;({ ensInstance } = await setup())
+})
+
+describe('getPrice', () => {
+  it('should return a base and premium price for an address', async () => {
+    const { base, premium } = (await ensInstance.getPrice(
+      'test123',
+      86400,
+      false,
+    ))!
+    expect(base.toNumber()).toBe(86400)
+    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.toNumber()).toBe(86400 * 2)
+    expect(premium.toNumber()).toBe(0)
+  })
+
+  describe('legacy mode', () => {
+    it('should return a base and premium price for an address', async () => {
+      const { base, premium } = (await ensInstance.getPrice(
+        'test123',
+        86400,
+        true,
+      ))!
+      expect(base.toNumber()).toBe(86400)
+      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.toNumber()).toBe(86400 * 2)
+      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,