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

package/src/functions/getNames.test.ts

@@ -1,11 +1,11 @@
 import { ENS } from '..'
-import { OwnedName, Registration } from '../functions/getNames'
 import setup from '../tests/setup'
+import { Name } from './getNames'
 
-let ENSInstance: ENS
+let ensInstance: ENS
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ensInstance } = await setup())
 })
 
 const testProperties = (obj: object, ...properties: string[]) =>
@@ -14,12 +14,45 @@ const testProperties = (obj: object, ...properties: string[]) =>
 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',
+  '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: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+    const result = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'registrant',
     })
     totalRegistrations = result.length
@@ -38,8 +71,8 @@ describe('getNames', () => {
     )
   })
   it('should get the owned names for an address', async () => {
-    const result = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+    const result = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
     })
     totalOwnedNames = result.length
@@ -56,191 +89,222 @@ describe('getNames', () => {
     )
     testNotProperties(result[0], 'expiryDate', 'registrationDate')
   })
+  it('should get wrapped domains for an address', async () => {
+    const result = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'wrappedOwner',
+    })
+    expect(result).toBeTruthy()
+    testProperties(
+      result[0],
+      'id',
+      'labelName',
+      'labelhash',
+      'name',
+      'isMigrated',
+      'parent',
+      'truncatedName',
+      'expiryDate',
+      'fuses',
+    )
+  })
   it('should get the registrations for an address with pagination', async () => {
-    const pageOne = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+    const pageOne = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'registrant',
       page: 0,
     })
     expect(pageOne).toHaveLength(10)
-    const pageTwo = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+    const pageTwo = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'registrant',
       page: 1,
     })
-    expect(pageTwo).toHaveLength(totalRegistrations % 10)
+    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: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+    const pageOne = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
       page: 0,
     })
     expect(pageOne).toHaveLength(10)
-    const pageTwo = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+    const pageTwo = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
       page: 1,
     })
     expect(pageTwo).toHaveLength(10)
-    const pageThree = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+    const pageThree = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
       page: 2,
     })
     expect(pageThree).toHaveLength(10)
-    const pageFour = await ENSInstance.getNames({
-      address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+    const pageFour = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
       type: 'owner',
       page: 3,
     })
-    expect(pageFour).toHaveLength(totalOwnedNames % 10)
+    expect(pageFour).toHaveLength(10)
+    const pageFive = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'owner',
+      page: 4,
+    })
+    expect(pageFive).toHaveLength(totalOwnedNames % 10)
+  })
+  it('should get wrapped domains for an address with pagination', async () => {
+    const pageOne = await ensInstance.getNames({
+      address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+      type: 'wrappedOwner',
+      page: 0,
+    })
+    expect(pageOne).toHaveLength(1)
   })
   describe('orderBy', () => {
     describe('registrations', () => {
       it('descending registrationDate', async () => {
-        const registrationDateOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        const registrationDateOrderedDesc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'registrationDate',
           orderDirection: 'desc',
-        })) as Registration[]
+        })) as Name[]
         registrationDateOrderedDesc.reduce((prev, curr) => {
-          expect(prev.registrationDate.getTime()).toBeGreaterThanOrEqual(
-            curr.registrationDate.getTime(),
+          expect(prev.registrationDate!.getTime()).toBeGreaterThanOrEqual(
+            curr.registrationDate!.getTime(),
           )
           return curr
         })
       })
       it('ascending registrationDate', async () => {
-        const registrationDateOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        const registrationDateOrderedAsc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'registrationDate',
           orderDirection: 'asc',
-        })) as Registration[]
+        })) as Name[]
         registrationDateOrderedAsc.reduce((prev, curr) => {
-          expect(prev.registrationDate.getTime()).toBeLessThanOrEqual(
-            curr.registrationDate.getTime(),
+          expect(prev.registrationDate!.getTime()).toBeLessThanOrEqual(
+            curr.registrationDate!.getTime(),
           )
           return curr
         })
       })
       it('descending expiryDate', async () => {
-        const expiryDateOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        const expiryDateOrderedDesc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'expiryDate',
           orderDirection: 'desc',
-        })) as Registration[]
+        })) as Name[]
         expiryDateOrderedDesc.reduce((prev, curr) => {
-          expect(prev.expiryDate.getTime()).toBeGreaterThanOrEqual(
-            curr.expiryDate.getTime(),
+          expect(prev.expiryDate!.getTime()).toBeGreaterThanOrEqual(
+            curr.expiryDate!.getTime(),
           )
           return curr
         })
       })
       it('ascending expiryDate', async () => {
-        const expiryDateOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        const expiryDateOrderedAsc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'expiryDate',
           orderDirection: 'asc',
-        })) as Registration[]
+        })) as Name[]
         expiryDateOrderedAsc.reduce((prev, curr) => {
-          expect(prev.expiryDate.getTime()).toBeLessThanOrEqual(
-            curr.expiryDate.getTime(),
+          expect(prev.expiryDate!.getTime()).toBeLessThanOrEqual(
+            curr.expiryDate!.getTime(),
           )
           return curr
         })
       })
       it('descending labelName', async () => {
-        const labelNameOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        const labelNameOrderedDesc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'labelName',
           orderDirection: 'desc',
-        })) as Registration[]
-        labelNameOrderedDesc.reduce((prev, curr) => {
-          expect((prev.labelName || '') > (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
+        })) as Name[]
+        expect(labelNameOrderedDesc.map((n) => n.labelName![0])).toStrictEqual(
+          letterItems,
+        )
       })
       it('ascending labelName', async () => {
-        const labelNameOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        const labelNameOrderedAsc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'registrant',
           orderBy: 'labelName',
           orderDirection: 'asc',
-        })) as Registration[]
-        labelNameOrderedAsc.reduce((prev, curr) => {
-          expect((prev.labelName || '') < (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
+        })) 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: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        const createdAtOrderedDesc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'owner',
           orderBy: 'createdAt',
           orderDirection: 'desc',
-        })) as OwnedName[]
+        })) as Name[]
         createdAtOrderedDesc.reduce((prev, curr) => {
-          expect(prev.createdAt.getTime()).toBeGreaterThanOrEqual(
-            curr.createdAt.getTime(),
+          expect(prev.createdAt!.getTime()).toBeGreaterThanOrEqual(
+            curr.createdAt!.getTime(),
           )
           return curr
         })
       })
       it('ascending createdAt', async () => {
-        const createdAtOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        const createdAtOrderedAsc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'owner',
           orderBy: 'createdAt',
           orderDirection: 'asc',
-        })) as OwnedName[]
+        })) as Name[]
         createdAtOrderedAsc.reduce((prev, curr) => {
-          expect(prev.createdAt.getTime()).toBeLessThanOrEqual(
-            curr.createdAt.getTime(),
+          expect(prev.createdAt!.getTime()).toBeLessThanOrEqual(
+            curr.createdAt!.getTime(),
           )
           return curr
         })
       })
       it('descending labelName', async () => {
-        const labelNameOrderedDesc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        const labelNameOrderedDesc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'owner',
           orderBy: 'labelName',
           orderDirection: 'desc',
-        })) as Registration[]
-        labelNameOrderedDesc.reduce((prev, curr) => {
-          if (
-            (!prev.labelName && !curr.labelName) ||
-            (!prev.labelName && curr.labelName)
-          )
-            return curr
-          expect((prev.labelName || '') > (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
+        })) as Name[]
+        expect(labelNameOrderedDesc.map((n) => n.name[0])).toStrictEqual(
+          domainLetterItems,
+        )
       })
       it('ascending labelName', async () => {
-        const labelNameOrderedAsc = (await ENSInstance.getNames({
-          address: '0x866B3c4994e1416B7C738B9818b31dC246b95eEE',
+        const labelNameOrderedAsc = (await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
           type: 'owner',
           orderBy: 'labelName',
           orderDirection: 'asc',
-        })) as Registration[]
-        labelNameOrderedAsc.reduce((prev, curr) => {
-          if (
-            (!prev.labelName && !curr.labelName) ||
-            (prev.labelName && !curr.labelName)
-          )
-            return curr
-          expect((prev.labelName || '') < (curr.labelName || '')).toBeTruthy()
-          return curr
-        })
+        })) as Name[]
+        expect(labelNameOrderedAsc.map((n) => n.name[0])).toStrictEqual(
+          domainLetterItems.reverse(),
+        )
       })
     })
   })

package/src/functions/getNames.ts

@@ -1,5 +1,6 @@
 import { ENSArgs } from '..'
 import { truncateFormat } from '../utils/format'
+import { CurrentFuses, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
 
 export type Name = {
@@ -15,12 +16,17 @@ export type Name = {
   createdAt?: Date
   registrationDate?: Date
   expiryDate?: Date
-  type: 'domain' | 'registration'
+  fuses?: CurrentFuses
+  registration?: {
+    expiryDate: Date
+    registrationDate: Date
+  }
+  type: 'domain' | 'registration' | 'wrappedDomain'
 }
 
 type BaseParams = {
   address: string
-  type: 'registrant' | 'owner' | 'all'
+  type: 'registrant' | 'owner' | 'wrappedOwner' | 'all'
   page?: number
   pageSize?: number
   orderDirection?: 'asc' | 'desc'
@@ -36,6 +42,11 @@ type OwnerParams = {
   orderBy?: 'createdAt' | 'labelName'
 }
 
+type WrappedOwnerParams = {
+  type: 'wrappedOwner'
+  orderBy?: 'expiryDate' | 'labelName'
+}
+
 type AllParams = {
   type: 'all'
   orderBy?: 'labelName' | 'creationDate'
@@ -43,7 +54,8 @@ type AllParams = {
   pageSize?: never
 }
 
-type Params = BaseParams & (RegistrantParams | OwnerParams | AllParams)
+type Params = BaseParams &
+  (RegistrantParams | OwnerParams | WrappedOwnerParams | AllParams)
 
 const mapDomain = (domain: any) => {
   const decrypted = decryptName(domain.name)
@@ -56,6 +68,22 @@ const mapDomain = (domain: any) => {
   }
 }
 
+const mapWrappedDomain = (wrappedDomain: any) => {
+  const domain = mapDomain(wrappedDomain.domain)
+  if (domain.registration) {
+    domain.registration = {
+      expiryDate: new Date(parseInt(domain.registration.expiryDate) * 1000),
+      registrationDate: new Date(domain.registration.registrationDate * 1000),
+    }
+  }
+  return {
+    expiryDate: new Date(parseInt(wrappedDomain.expiryDate) * 1000),
+    fuses: decodeFuses(wrappedDomain.fuses),
+    ...domain,
+    type: 'wrappedDomain',
+  }
+}
+
 const mapRegistration = (registration: any) => {
   const decrypted = decryptName(registration.domain.name)
   return {
@@ -76,7 +104,7 @@ const getNames = async (
     page,
     pageSize = 10,
     orderDirection,
-    orderBy,
+    orderBy = 'labelName',
   }: Params,
 ) => {
   const address = _address.toLowerCase()
@@ -116,6 +144,17 @@ const getNames = async (
             ${domainQueryData}
             createdAt
           }
+          wrappedDomains(first: 1000) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              registration {
+                registrationDate
+                expiryDate
+              }
+            }
+          }
         }
       }
     `
@@ -175,9 +214,73 @@ const getNames = async (
         orderDirection,
       }
     }
-  } else {
+  } else if (type === 'wrappedOwner') {
     if (typeof page !== 'number') {
       finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $orderBy: WrappedDomain_orderBy
+        $orderDirection: OrderDirection
+        $expiryDate: Int
+      ) {
+        account(id: $id) {
+          wrappedDomains(
+            orderBy: $orderBy
+            orderDirection: $orderDirection
+            where: { expiryDate_gt: $expiryDate }
+          ) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      }
+    `
+
+      queryVars = {
+        id: address,
+        expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
+      }
+    } else {
+      finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $first: Int
+        $skip: Int
+        $orderBy: WrappedDomain_orderBy
+        $orderDirection: OrderDirection
+      ) {
+        account(id: $id) {
+          wrappedDomains(
+            first: $first
+            skip: $skip
+            orderBy: $orderBy
+            orderDirection: $orderDirection
+          ) {
+            expiryDate
+            fuses
+            domain {
+              ${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
@@ -200,14 +303,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,42 +337,43 @@ 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,
     }
   }
 
-  const { account } = await client.request(finalQuery, queryVars)
+  const response = await client.request(finalQuery, queryVars)
+  const account = response?.account
   if (type === 'all') {
     return [
-      ...account.domains.map(mapDomain),
-      ...account.registrations.map(mapRegistration),
+      ...(account?.domains.map(mapDomain) || []),
+      ...(account?.registrations.map(mapRegistration) || []),
+      ...(account?.wrappedDomains.map(mapWrappedDomain) || []),
     ].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()
         }
+        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') {
-    return account.domains.map(mapDomain) as Name[]
-  } else {
-    return account.registrations.map(mapRegistration) as Name[]
   }
+  if (type === 'owner') {
+    return (account?.domains.map(mapDomain) || []) as Name[]
+  }
+  if (type === 'wrappedOwner') {
+    return (account?.wrappedDomains.map(mapWrappedDomain) || []) as Name[]
+  }
+  return (account?.registrations.map(mapRegistration) || []) as Name[]
 }
 
 export default getNames