@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.61

package/src/functions/getNames.ts

@@ -1,6 +1,8 @@
 import { ENSArgs } from '..'
 import { truncateFormat } from '../utils/format'
+import { AllCurrentFuses, checkPCCBurned, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
+import { Domain, Registration, WrappedDomain } from '../utils/subgraph-types'
 
 export type Name = {
   id: string
@@ -15,12 +17,19 @@ export type Name = {
   createdAt?: Date
   registrationDate?: Date
   expiryDate?: Date
-  type: 'domain' | 'registration'
+  fuses?: AllCurrentFuses
+  registration?: {
+    expiryDate: Date
+    registrationDate: Date
+  }
+  owner?: string
+  manager?: string
+  type: 'domain' | 'registration' | 'wrappedDomain'
 }
 
 type BaseParams = {
   address: string
-  type: 'registrant' | 'owner' | 'all'
+  type: 'registrant' | 'owner' | 'wrappedOwner' | 'all' | 'resolvedAddress'
   page?: number
   pageSize?: number
   orderDirection?: 'asc' | 'desc'
@@ -36,6 +45,11 @@ type OwnerParams = {
   orderBy?: 'createdAt' | 'labelName'
 }
 
+type WrappedOwnerParams = {
+  type: 'wrappedOwner'
+  orderBy?: 'expiryDate' | 'name'
+}
+
 type AllParams = {
   type: 'all'
   orderBy?: 'labelName' | 'creationDate'
@@ -43,31 +57,119 @@ type AllParams = {
   pageSize?: never
 }
 
-type Params = BaseParams & (RegistrantParams | OwnerParams | AllParams)
+type ResolvedAddressParams = {
+  type: 'resolvedAddress'
+  orderBy?: 'labelName' | 'createdAt'
+  page?: never
+  pageSize?: never
+}
+
+type Params = BaseParams &
+  (
+    | RegistrantParams
+    | OwnerParams
+    | WrappedOwnerParams
+    | AllParams
+    | ResolvedAddressParams
+  )
+
+const mapDomain = (domain?: Domain) => {
+  if (!domain) return {}
 
-const mapDomain = (domain: any) => {
-  const decrypted = decryptName(domain.name)
+  const decrypted = domain.name ? decryptName(domain.name) : undefined
   return {
     ...domain,
+    ...(domain.registration
+      ? {
+          registration: {
+            expiryDate: new Date(
+              parseInt(domain.registration.expiryDate) * 1000,
+            ),
+            registrationDate: new Date(
+              parseInt(domain.registration.registrationDate) * 1000,
+            ),
+          },
+        }
+      : {}),
     name: decrypted,
-    truncatedName: truncateFormat(decrypted),
+    truncatedName: decrypted ? truncateFormat(decrypted) : undefined,
     createdAt: new Date(parseInt(domain.createdAt) * 1000),
     type: 'domain',
   }
 }
 
-const mapRegistration = (registration: any) => {
-  const decrypted = decryptName(registration.domain.name)
+const mapWrappedDomain = (wrappedDomain: WrappedDomain) => {
+  const expiryDate =
+    wrappedDomain.expiryDate && wrappedDomain.expiryDate !== '0'
+      ? new Date(parseInt(wrappedDomain.expiryDate) * 1000)
+      : undefined
+  if (
+    expiryDate &&
+    expiryDate < new Date() &&
+    checkPCCBurned(wrappedDomain.fuses)
+  ) {
+    // PCC was burned previously and now the fuses are expired meaning that the
+    // owner is now 0x0 so we need to filter this out
+    // if a user's local time is out of sync with the blockchain, this could potentially
+    // be incorrect. the likelihood of that happening though is very low, and devs
+    // shouldn't be relying on this value for anything critical anyway.
+    return null
+  }
+
+  const domain = mapDomain(wrappedDomain.domain)
+
+  return {
+    expiryDate,
+    fuses: decodeFuses(wrappedDomain.fuses),
+    ...domain,
+    type: 'wrappedDomain',
+  }
+}
+
+const mapRegistration = (registration: Registration) => {
+  const decrypted = decryptName(registration.domain.name!)
+  const domain = mapDomain(registration.domain)
   return {
     expiryDate: new Date(parseInt(registration.expiryDate) * 1000),
     registrationDate: new Date(parseInt(registration.registrationDate) * 1000),
-    ...registration.domain,
+    ...domain,
     name: decrypted,
     truncatedName: truncateFormat(decrypted),
     type: 'registration',
   }
 }
 
+const mapResolvedAddress = ({
+  wrappedDomain,
+  registration,
+  ...domain
+}: Domain) => {
+  const mappedDomain = mapDomain(domain)
+  if (wrappedDomain) {
+    const mappedWrappedDomain = mapWrappedDomain(wrappedDomain)
+    // If wrapped domain is expired then filter it out.
+    if (!mappedWrappedDomain) return null
+    return {
+      ...mappedDomain,
+      ...mappedWrappedDomain,
+      owner: wrappedDomain.owner.id,
+    }
+  }
+  return {
+    ...mappedDomain,
+    ...(registration
+      ? {
+          expiryDate: new Date(parseInt(registration.expiryDate) * 1000),
+          registrationDate: new Date(
+            parseInt(registration.registrationDate) * 1000,
+          ),
+          owner: registration.registrant.id,
+        }
+      : {}),
+    manager: domain.owner.id,
+  }
+}
+
 const getNames = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
   {
@@ -76,7 +178,7 @@ const getNames = async (
     page,
     pageSize = 10,
     orderDirection,
-    orderBy,
+    orderBy = 'labelName',
   }: Params,
 ) => {
   const address = _address.toLowerCase()
@@ -90,6 +192,7 @@ const getNames = async (
     parent {
         name
     }
+    createdAt
   `
 
   let queryVars: object = {}
@@ -114,7 +217,21 @@ const getNames = async (
           }
           domains(first: 1000) {
             ${domainQueryData}
-            createdAt
+            registration {
+              registrationDate
+              expiryDate
+            }
+          }
+          wrappedDomains(first: 1000) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              registration {
+                registrationDate
+                expiryDate
+              }
+            }
           }
         }
       }
@@ -123,6 +240,47 @@ const getNames = async (
       id: address,
       expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
     }
+  } else if (type === 'resolvedAddress') {
+    finalQuery = gqlInstance.gql`
+    query getNames(
+      $id: String!
+      $orderBy: Domain_orderBy
+      $orderDirection: OrderDirection
+    ) {
+      domains(
+        first: 1000
+        where: { 
+           resolvedAddress: $id 
+        }
+        orderBy: $orderBy
+        orderDirection: $orderDirection
+      ) {
+        ${domainQueryData}
+        owner {
+          id
+        }
+        registration {
+          registrationDate
+          expiryDate
+          registrant {
+            id
+          }
+        }
+        wrappedDomain {
+          expiryDate
+          fuses
+          owner {
+            id
+          }
+        }
+      }
+    }`
+
+    queryVars = {
+      id: address,
+      orderBy: orderBy === 'labelName' ? 'labelName' : 'createdAt',
+      orderDirection: orderDirection === 'asc' ? 'asc' : 'desc',
+    }
   } else if (type === 'owner') {
     if (typeof page !== 'number') {
       finalQuery = gqlInstance.gql`
@@ -134,7 +292,10 @@ const getNames = async (
           account(id: $id) {
             domains(orderBy: $orderBy, orderDirection: $orderDirection) {
               ${domainQueryData}
-              createdAt
+              registration {
+                registrationDate
+                expiryDate
+              }
             }
           }
         }
@@ -161,7 +322,6 @@ const getNames = async (
               orderDirection: $orderDirection
             ) {
               ${domainQueryData}
-              createdAt
             }
           }
         }
@@ -175,9 +335,71 @@ 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}
+            }
+          }
+        }
+      }
+    `
+
+      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}
+            }
+          }
+        }
+      }
+    `
+
+      queryVars = {
+        id: address,
+        first: pageSize,
+        skip: (page || 0) * pageSize,
+        orderBy: orderBy === 'labelName' ? 'name' : orderBy,
+        orderDirection,
+      }
+    }
+  } else if (typeof page !== 'number') {
+    finalQuery = gqlInstance.gql`
         query getNames(
           $id: ID!
           $orderBy: Registration_orderBy
@@ -200,14 +422,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 +456,50 @@ 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).filter((d: any) => d) ||
+        []),
     ].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 === 'resolvedAddress') {
+    return (response?.domains.map(mapResolvedAddress).filter((d: any) => d) ||
+      []) as Name[]
+  }
+  if (type === 'owner') {
+    return (account?.domains.map(mapDomain) || []) as Name[]
+  }
+  if (type === 'wrappedOwner') {
+    return (account?.wrappedDomains
+      .map(mapWrappedDomain)
+      .filter((d: any) => d) || []) as Name[]
+  }
+  return (account?.registrations.map(mapRegistration) || []) as Name[]
 }
 
 export default getNames

package/src/functions/getOwner.test.ts

@@ -1,19 +1,15 @@
-import { ethers } from 'ethers'
+import { JsonRpcProvider } from '@ethersproject/providers'
 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 provider: JsonRpcProvider
 let accounts: string[]
 
 beforeAll(async () => {
-  ;({ ENSInstance, revert, provider } = await setup())
+  ;({ ensInstance, revert, provider } = await setup())
   accounts = await provider.listAccounts()
-  const tx = await ENSInstance.wrapName('parthtejpal.eth', {
-    wrappedOwner: accounts[0],
-  })
-  await tx.wait()
 })
 
 afterAll(async () => {
@@ -21,53 +17,63 @@ 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 correct ownership level and values for a wrapped .eth name', async () => {
+    const result = await ensInstance.getOwner('wrapped.eth')
+    expect(result).toEqual({
+      ownershipLevel: 'nameWrapper',
+      owner: accounts[1],
+      expired: false,
+    })
   })
-  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 correct ownership level and values for an expired wrapped .eth name', async () => {
+    const result = await ensInstance.getOwner('expired-wrapped.eth')
+    expect(result).toEqual({
+      ownershipLevel: 'nameWrapper',
+      owner: '0x0000000000000000000000000000000000000000',
+      expired: true,
     })
   })
-  it('should return nameWrapper as the ownership level for a wrapped name', async () => {
-    const result = await ENSInstance.getOwner('parthtejpal.eth')
-    expect(result?.ownershipLevel).toBe('nameWrapper')
+  it('should return correct ownership level and values for an unwrapped .eth name', async () => {
+    const result = await ensInstance.getOwner('test123.eth')
+    expect(result).toEqual({
+      ownershipLevel: 'registrar',
+      owner: accounts[1],
+      registrant: accounts[1],
+      expired: false,
+    })
   })
-  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 correct ownership level and values for an expired unwrapped .eth name', async () => {
+    const result = await ensInstance.getOwner('expired.eth')
+    expect(result).toEqual({
+      ownershipLevel: 'registrar',
+      owner: accounts[1],
+      registrant: accounts[1].toLowerCase(),
+      expired: true,
+    })
   })
-  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(),
-    )
+  describe('subname', () => {
+    it('should return correct ownership level and values for a unwrapped name', async () => {
+      const result = await ensInstance.getOwner('test.with-subnames.eth')
+      expect(result).toEqual({
+        ownershipLevel: 'registry',
+        owner: accounts[2],
+      })
+    })
+    it('should return correct ownership level and values for a wrapped name', async () => {
+      const result = await ensInstance.getOwner(
+        'test.wrapped-with-subnames.eth',
+      )
+      expect(result).toEqual({
+        ownershipLevel: 'nameWrapper',
+        owner: accounts[2],
+      })
+    })
+    it('should return correct ownership level and values for an expired wrapped name', async () => {
+      const result = await ensInstance.getOwner('test.expired-wrapped.eth')
+      expect(result).toEqual({
+        ownershipLevel: 'nameWrapper',
+        owner: accounts[2],
+      })
+    })
   })
-  // 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')
-  // })
 })