@ensdomains/ensjs 3.0.0-alpha.5 → 3.0.0-alpha.50

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,17 @@ export type Name = {
   createdAt?: Date
   registrationDate?: Date
   expiryDate?: Date
-  type: 'domain' | 'registration'
+  fuses?: AllCurrentFuses
+  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 +43,11 @@ type OwnerParams = {
   orderBy?: 'createdAt' | 'labelName'
 }
 
+type WrappedOwnerParams = {
+  type: 'wrappedOwner'
+  orderBy?: 'expiryDate' | 'name'
+}
+
 type AllParams = {
   type: 'all'
   orderBy?: 'labelName' | 'creationDate'
@@ -43,21 +55,63 @@ type AllParams = {
   pageSize?: never
 }
 
-type Params = BaseParams & (RegistrantParams | OwnerParams | AllParams)
+type Params = BaseParams &
+  (RegistrantParams | OwnerParams | WrappedOwnerParams | AllParams)
+
+const mapDomain = ({ name, ...domain }: Domain) => {
+  const decrypted = name ? decryptName(name) : undefined
 
-const mapDomain = (domain: any) => {
-  const decrypted = decryptName(domain.name)
   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!)
   return {
     expiryDate: new Date(parseInt(registration.expiryDate) * 1000),
     registrationDate: new Date(parseInt(registration.registrationDate) * 1000),
@@ -76,7 +130,7 @@ const getNames = async (
     page,
     pageSize = 10,
     orderDirection,
-    orderBy,
+    orderBy = 'labelName',
   }: Params,
 ) => {
   const address = _address.toLowerCase()
@@ -90,6 +144,7 @@ const getNames = async (
     parent {
         name
     }
+    createdAt
   `
 
   let queryVars: object = {}
@@ -114,7 +169,21 @@ const getNames = async (
           }
           domains(first: 1000) {
             ${domainQueryData}
-            createdAt
+            registration {
+              registrationDate
+              expiryDate
+            }
+          }
+          wrappedDomains(first: 1000) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              registration {
+                registrationDate
+                expiryDate
+              }
+            }
           }
         }
       }
@@ -134,7 +203,10 @@ const getNames = async (
           account(id: $id) {
             domains(orderBy: $orderBy, orderDirection: $orderDirection) {
               ${domainQueryData}
-              createdAt
+              registration {
+                registrationDate
+                expiryDate
+              }
             }
           }
         }
@@ -161,7 +233,6 @@ const getNames = async (
               orderDirection: $orderDirection
             ) {
               ${domainQueryData}
-              createdAt
             }
           }
         }
@@ -175,9 +246,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 +333,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 +367,46 @@ 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 === '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')
-  // })
 })

package/src/functions/getOwner.ts

@@ -1,12 +1,16 @@
-import { ethers } from 'ethers'
+import type { Result } from '@ethersproject/abi'
+import { defaultAbiCoder } from '@ethersproject/abi'
+import { hexStripZeros } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { labelhash } from '../utils/labels'
 import { namehash as makeNamehash } from '../utils/normalise'
+import { checkIsDotEth } from '../utils/validation'
 
 type Owner = {
   registrant?: string
   owner?: string
   ownershipLevel: 'nameWrapper' | 'registry' | 'registrar'
+  expired?: boolean
 }
 
 const singleContractOwnerRaw = async (
@@ -42,6 +46,7 @@ const singleContractOwnerRaw = async (
         ]),
       }
     }
+    // no default
   }
 }
 
@@ -54,7 +59,7 @@ const raw = async (
   const labels = name.split('.')
 
   if (contract || labels.length === 1) {
-    return await singleContractOwnerRaw(
+    return singleContractOwnerRaw(
       { contracts },
       contract || 'registry',
       namehash,
@@ -83,27 +88,43 @@ const raw = async (
 
   const data: { to: string; data: string }[] = [registryData, nameWrapperData]
 
-  if (labels.length == 2 && labels[1] === 'eth') {
+  if (checkIsDotEth(labels)) {
     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,38 +132,59 @@ 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
+  const registryOwner = (decodedData[0] as Result)[0]
+  const nameWrapperOwner = (decodedData[1] as Result)[0]
+  let registrarOwner: string | undefined = (
+    decodedData[2] as Result | undefined
   )?.[0]
+  let baseReturnObject: {
+    expired?: boolean
+  } = {}
 
   // check for only .eth names
   if (labels[labels.length - 1] === 'eth') {
+    // if there is no registrar owner, the name is expired
+    // but we still want to get the registrar owner prior to expiry
+    if (labels.length === 2) {
+      if (!registrarOwner) {
+        const graphRegistrantResult = await gqlInstance.client.request(
+          registrantQuery,
+          {
+            namehash: makeNamehash(name),
+          },
+        )
+        registrarOwner =
+          graphRegistrantResult.domain?.registration?.registrant?.id
+        baseReturnObject = {
+          expired: true,
+        }
+      } else {
+        baseReturnObject = {
+          expired: false,
+        }
+      }
+    }
     // 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) {
+    if (registrarOwner?.toLowerCase() === nameWrapper.address.toLowerCase()) {
       return {
         owner: nameWrapperOwner,
         ownershipLevel: 'nameWrapper',
+        ...baseReturnObject,
       }
     }
     // if there is a registrar owner, then it's not a subdomain but we have also passed the namewrapper clause
@@ -154,14 +196,26 @@ const decode = async (
         registrant: registrarOwner,
         owner: registryOwner,
         ownershipLevel: 'registrar',
+        ...baseReturnObject,
       }
     }
-    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',
+          expired: true,
+        }
+      }
       // 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 +235,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 +247,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',