@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

package/src/functions/getNames.test.ts

@@ -0,0 +1,276 @@
+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 = [
+  '[',
+  'w',
+  't',
+  't',
+  '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(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

@@ -0,0 +1,275 @@
+import { ENSArgs } from '..'
+import { truncateFormat } from '../utils/format'
+import { decryptName } from '../utils/labels'
+
+export type Name = {
+  id: string
+  labelName: string | null
+  truncatedName?: string
+  labelhash: string
+  isMigrated: boolean
+  name: string
+  parent: {
+    name: string
+  }
+  createdAt?: Date
+  registrationDate?: Date
+  expiryDate?: Date
+  type: 'domain' | 'registration'
+}
+
+type BaseParams = {
+  address: string
+  type: 'registrant' | 'owner' | 'all'
+  page?: number
+  pageSize?: number
+  orderDirection?: 'asc' | 'desc'
+}
+
+type RegistrantParams = {
+  type: 'registrant'
+  orderBy?: 'registrationDate' | 'expiryDate' | 'labelName'
+}
+
+type OwnerParams = {
+  type: 'owner'
+  orderBy?: 'createdAt' | 'labelName'
+}
+
+type AllParams = {
+  type: 'all'
+  orderBy?: 'labelName' | 'creationDate'
+  page?: never
+  pageSize?: never
+}
+
+type Params = BaseParams & (RegistrantParams | OwnerParams | AllParams)
+
+const mapDomain = (domain: any) => {
+  const decrypted = decryptName(domain.name)
+  return {
+    ...domain,
+    name: decrypted,
+    truncatedName: truncateFormat(decrypted),
+    createdAt: new Date(parseInt(domain.createdAt) * 1000),
+    type: 'domain',
+  }
+}
+
+const mapRegistration = (registration: any) => {
+  const decrypted = decryptName(registration.domain.name)
+  return {
+    expiryDate: new Date(parseInt(registration.expiryDate) * 1000),
+    registrationDate: new Date(parseInt(registration.registrationDate) * 1000),
+    ...registration.domain,
+    name: decrypted,
+    truncatedName: truncateFormat(decrypted),
+    type: 'registration',
+  }
+}
+
+const getNames = async (
+  { gqlInstance }: ENSArgs<'gqlInstance'>,
+  {
+    address: _address,
+    type,
+    page,
+    pageSize = 10,
+    orderDirection,
+    orderBy,
+  }: Params,
+) => {
+  const address = _address.toLowerCase()
+  const client = gqlInstance.client!
+  const domainQueryData = `
+    id
+    labelName
+    labelhash
+    name
+    isMigrated
+    parent {
+        name
+    }
+  `
+
+  let queryVars: object = {}
+  let finalQuery: string = ''
+
+  if (type === 'all') {
+    finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $expiryDate: Int
+      ) {
+        account(id: $id) {
+          registrations(
+            first: 1000
+            where: { expiryDate_gt: $expiryDate }
+          ) {
+            registrationDate
+            expiryDate
+            domain {
+              ${domainQueryData}
+            }
+          }
+          domains(first: 1000) {
+            ${domainQueryData}
+            createdAt
+          }
+        }
+      }
+    `
+    queryVars = {
+      id: address,
+      expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
+    }
+  } else if (type === 'owner') {
+    if (typeof page !== 'number') {
+      finalQuery = gqlInstance.gql`
+        query getNames(
+          $id: ID! 
+          $orderBy: Domain_orderBy 
+          $orderDirection: OrderDirection
+        ) {
+          account(id: $id) {
+            domains(orderBy: $orderBy, orderDirection: $orderDirection) {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      `
+      queryVars = {
+        id: address,
+        orderBy,
+        orderDirection,
+      }
+    } else {
+      finalQuery = gqlInstance.gql`
+        query getNames(
+          $id: ID!
+          $first: Int
+          $skip: Int
+          $orderBy: Domain_orderBy
+          $orderDirection: OrderDirection
+        ) {
+          account(id: $id) {
+            domains(
+              first: $first
+              skip: $skip
+              orderBy: $orderBy
+              orderDirection: $orderDirection
+            ) {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      `
+
+      queryVars = {
+        id: address,
+        first: pageSize,
+        skip: (page || 0) * pageSize,
+        orderBy,
+        orderDirection,
+      }
+    }
+  } else {
+    if (typeof page !== 'number') {
+      finalQuery = gqlInstance.gql`
+        query getNames(
+          $id: ID!
+          $orderBy: Registration_orderBy
+          $orderDirection: OrderDirection
+          $expiryDate: Int
+        ) {
+          account(id: $id) {
+            registrations(
+              orderBy: $orderBy
+              orderDirection: $orderDirection
+              where: { expiryDate_gt: $expiryDate }
+            ) {
+              registrationDate
+              expiryDate
+              domain {
+                ${domainQueryData}
+              }
+            }
+          }
+        }
+      `
+
+      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
+          $skip: Int
+          $orderBy: Registration_orderBy
+          $orderDirection: OrderDirection
+          $expiryDate: Int
+        ) {
+          account(id: $id) {
+            registrations(
+              first: $first
+              skip: $skip
+              orderBy: $orderBy
+              orderDirection: $orderDirection
+              where: { expiryDate_gt: $expiryDate }
+            ) {
+              registrationDate
+              expiryDate
+              domain {
+                ${domainQueryData}
+              }
+            }
+          }
+        }
+      `
+
+      queryVars = {
+        id: address,
+        first: pageSize,
+        skip: (page || 0) * pageSize,
+        orderBy: orderBy,
+        orderDirection: orderDirection,
+        expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
+      }
+    }
+  }
+
+  const { account } = await client.request(finalQuery, queryVars)
+  if (type === 'all') {
+    return [
+      ...account.domains.map(mapDomain),
+      ...account.registrations.map(mapRegistration),
+    ].sort((a, b) => {
+      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()
+        }
+      }
+    }) as Name[]
+  } else if (type === 'owner') {
+    return account.domains.map(mapDomain) as Name[]
+  } else {
+    return account.registrations.map(mapRegistration) as Name[]
+  }
+}
+
+export default getNames

package/src/functions/getOwner.test.ts

@@ -0,0 +1,58 @@
+import { ethers } from 'ethers'
+import { ENS } from '..'
+import setup from '../tests/setup'
+
+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()
+})
+
+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')
+  })
+})