@ensdomains/ensjs 3.0.0-alpha.62 → 3.0.0-alpha.64

package/src/functions/getOwner.ts

@@ -1,18 +1,29 @@
 import type { Result } from '@ethersproject/abi'
 import { defaultAbiCoder } from '@ethersproject/abi'
 import { hexStripZeros } from '@ethersproject/bytes'
+import { GraphQLError } from 'graphql'
 import { ENSArgs } from '..'
 import { labelhash } from '../utils/labels'
 import { namehash as makeNamehash } from '../utils/normalise'
 import { checkIsDotEth } from '../utils/validation'
+import {
+  debugSubgraphLatency,
+  getClientErrors,
+  ENSJSError,
+} from '../utils/errors'
 
-type Owner = {
+export type Owner = {
   registrant?: string
   owner?: string
   ownershipLevel: 'nameWrapper' | 'registry' | 'registrar'
   expired?: boolean
 }
 
+type GetOwnerOptions = {
+  contract?: 'nameWrapper' | 'registry' | 'registrar'
+  skipGraph?: boolean
+}
+
 const singleContractOwnerRaw = async (
   { contracts }: ENSArgs<'contracts'>,
   contract: 'nameWrapper' | 'registry' | 'registrar',
@@ -53,8 +64,10 @@ const singleContractOwnerRaw = async (
 const raw = async (
   { contracts, multicallWrapper }: ENSArgs<'contracts' | 'multicallWrapper'>,
   name: string,
-  contract?: 'nameWrapper' | 'registry' | 'registrar',
+  options: GetOwnerOptions = {},
 ) => {
+  const { contract } = options
+
   const namehash = makeNamehash(name)
   const labels = name.split('.')
 
@@ -118,10 +131,16 @@ const decode = async (
   }: ENSArgs<'contracts' | 'multicallWrapper' | 'gqlInstance'>,
   data: string,
   name: string,
-  contract?: 'nameWrapper' | 'registry' | 'registrar',
+  options: GetOwnerOptions = {},
 ): Promise<Owner | undefined> => {
   if (!data) return
+
+  const { contract, skipGraph = true } = options
+
   const labels = name.split('.')
+  const isEth = labels[labels.length - 1] === 'eth'
+  const is2LD = labels.length === 2
+
   if (contract || labels.length === 1) {
     const singleOwner = singleContractOwnerDecode(data)
     const obj = {
@@ -156,59 +175,107 @@ const decode = async (
   } = {}
 
   // check for only .eth names
-  if (labels[labels.length - 1] === 'eth') {
+  if (isEth) {
+    let graphErrors: GraphQLError[] | undefined
+
     // 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,
-          {
+    if (is2LD) {
+      if (!registrarOwner && !skipGraph) {
+        const graphRegistrantResult = await gqlInstance.client
+          .request(registrantQuery, {
             namehash: makeNamehash(name),
-          },
-        )
+          })
+          .catch((e: unknown) => {
+            console.error(e)
+            graphErrors = getClientErrors(e)
+            return undefined
+          })
+          .finally(debugSubgraphLatency)
         registrarOwner =
-          graphRegistrantResult.domain?.registration?.registrant?.id
+          graphRegistrantResult?.domain?.registration?.registrant?.id
         baseReturnObject = {
           expired: true,
         }
       } else {
         baseReturnObject = {
-          expired: false,
+          expired: !registrarOwner,
         }
       }
     }
+
+    // If baseReturnObject.expired is true, then we know that the name is expired and a 2LD eth name.
+    // If the reigstry owner is the nameWrapper, then we know it's a wrapped name.
+    if (
+      baseReturnObject.expired &&
+      registryOwner?.toLowerCase() === nameWrapper.address.toLowerCase()
+    ) {
+      const owner: Owner = {
+        owner: nameWrapperOwner,
+        ownershipLevel: 'nameWrapper',
+        ...baseReturnObject,
+      }
+      if (graphErrors) {
+        throw new ENSJSError({
+          data: owner,
+          errors: graphErrors,
+        })
+      }
+      return owner
+    }
+
     // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner
-    // there is no "registrant" for wrapped names
+    // there is no "registrant" for wrapped names.
     if (registrarOwner?.toLowerCase() === nameWrapper.address.toLowerCase()) {
-      return {
+      const owner: Owner = {
         owner: nameWrapperOwner,
         ownershipLevel: 'nameWrapper',
         ...baseReturnObject,
       }
+      if (graphErrors) {
+        throw new ENSJSError({
+          data: owner,
+          errors: graphErrors,
+        })
+      }
+      return owner
     }
     // if there is a registrar owner, then it's not a subdomain but we have also passed the namewrapper clause
     // this means that it's an unwrapped second-level name
     // the registrant is the owner of the NFT
     // the owner is the controller of the records
     if (registrarOwner) {
-      return {
+      const owner: Owner = {
         registrant: registrarOwner,
         owner: registryOwner,
         ownershipLevel: 'registrar',
         ...baseReturnObject,
       }
+      if (graphErrors) {
+        throw new ENSJSError({
+          data: owner,
+          errors: graphErrors,
+        })
+      }
+      return owner
     }
     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 {
+        const owner: Owner = {
           registrant: undefined,
           owner: registryOwner,
           ownershipLevel: 'registrar',
           expired: true,
         }
+        if (graphErrors) {
+          throw new ENSJSError({
+            data: owner,
+            errors: graphErrors,
+          })
+        }
+        return owner
       }
       // this means that the subname is wrapped
       if (
@@ -228,7 +295,12 @@ const decode = async (
       }
     }
     // .eth names with no registrar owner are either unregistered or expired
-    return
+    if (graphErrors) {
+      throw new ENSJSError({
+        errors: graphErrors,
+      })
+    }
+    return undefined
   }
 
   // non .eth names inherit the owner from the registry

package/src/functions/getProfile.test.ts

@@ -2,6 +2,7 @@ import dotenv from 'dotenv'
 import { ethers } from 'ethers'
 import { ENS } from '..'
 import setup, { deploymentAddresses } from '../tests/setup'
+import { ENSJSError } from '../utils/errors'
 
 dotenv.config()
 
@@ -78,6 +79,42 @@ describe('getProfile', () => {
       )
       expect(result).toBeUndefined()
     })
+
+    describe('skipGraph', () => {
+      it('should return undefined if skipGraph is true', async () => {
+        const result = await ensInstance.getProfile(
+          '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          { skipGraph: true },
+        )
+        expect(result).toBeUndefined()
+      })
+
+      it('should return undefined with specified records and skipGraph is true', async () => {
+        const result = await ensInstance.getProfile(
+          '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          {
+            texts: ['description', 'url'],
+            coinTypes: ['ETC_LEGACY', '0'],
+            skipGraph: true,
+          },
+        )
+        expect(result).toBeUndefined()
+      })
+
+      it('should return fallback records if skipGraph is true', async () => {
+        const result = await ensInstance.getProfile(
+          '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          {
+            fallback: {
+              texts: ['description', 'url'],
+              coinTypes: ['ETC_LEGACY', '0'],
+            },
+            skipGraph: true,
+          },
+        )
+        checkRecords(result, 2, 3)
+      })
+    })
   })
   describe('with a name', () => {
     it('should return a profile object with no other args', async () => {
@@ -130,6 +167,33 @@ describe('getProfile', () => {
       const result = await ensInstance.getProfile('test123123123cool.eth')
       expect(result).toBeUndefined()
     })
+
+    describe('skipGraph', () => {
+      it('should return undefined if skipGraph is true', async () => {
+        const result = await ensInstance.getProfile('with-profile.eth', {
+          skipGraph: true,
+        })
+        expect(result).toBeUndefined()
+      })
+      it('should return undefined if skipGraph is true with specified records', async () => {
+        const result = await ensInstance.getProfile('with-profile.eth', {
+          texts: ['description', 'url'],
+          coinTypes: ['ETC_LEGACY', '0'],
+          skipGraph: true,
+        })
+        expect(result).toBeUndefined()
+      })
+      it('should return a profile object if skipGraph is true with fallback options', async () => {
+        const result = await ensInstance.getProfile('with-profile.eth', {
+          fallback: {
+            texts: ['description', 'url'],
+            coinTypes: ['ETC_LEGACY', '0'],
+          },
+          skipGraph: true,
+        })
+        checkRecords(result, 2, 3)
+      })
+    })
   })
   describe('with an old resolver', () => {
     it('should use fallback methods for a name with an older resolver (no multicall)', async () => {
@@ -213,14 +277,77 @@ describe('getProfile', () => {
       const result = await ensInstance.getProfile('wrapped.eth', {
         resolverAddress: '0xb794F5eA0ba39494cE839613fffBA74279579268',
       })
-      expect(result).toBeDefined()
       if (result) {
         expect(result.address).toBeFalsy()
-        expect(Object.keys(result.records!).length).toBe(0)
+        const recordsKeys = Object.keys(result.records!).filter(
+          (key) => key !== 'contentHash',
+        )
+        expect(recordsKeys.length).toBe(0)
+        const contentHash = result.records!.contentHash || {}
+        expect(Object.keys(contentHash).length).toBe(0)
         expect(result.resolverAddress).toBe(
           '0xb794F5eA0ba39494cE839613fffBA74279579268',
         )
       }
     })
   })
+
+  describe('errors', () => {
+    beforeAll(() => {
+      process.env.NEXT_PUBLIC_ENSJS_DEBUG = 'on'
+      localStorage.setItem('ensjs-debug', 'ENSJSSubgraphError')
+    })
+
+    afterAll(() => {
+      process.env.NEXT_PUBLIC_ENSJS_DEBUG = ''
+      localStorage.removeItem('ensjs-debug')
+    })
+
+    it('should throw an ensjs error with no data', async () => {
+      try {
+        await ensInstance.getProfile('with-profile.eth')
+        expect(true).toBeFalsy()
+      } catch (e) {
+        expect(e).toBeInstanceOf(ENSJSError)
+        const error = e as ENSJSError<any>
+        expect(error.name).toBe('ENSJSSubgraphError')
+        expect(error.data).toBeUndefined()
+      }
+    })
+
+    it('should throw error with data of fallback records', async () => {
+      try {
+        await ensInstance.getProfile(
+          '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          {
+            fallback: {
+              texts: ['description', 'url'],
+              coinTypes: ['ETC_LEGACY', '0'],
+            },
+          },
+        )
+        expect(true).toBeFalsy()
+      } catch (e) {
+        expect(e).toBeInstanceOf(ENSJSError)
+        const error = e as ENSJSError<any>
+        expect(error.name).toBe('ENSJSSubgraphError')
+        checkRecords(error.data, 2, 3)
+      }
+    })
+
+    it('should not throw an ensjs error if skipGraph is true', async () => {
+      try {
+        const result = await ensInstance.getProfile('with-profile.eth', {
+          skipGraph: true,
+          fallback: {
+            texts: ['description', 'url'],
+            coinTypes: ['ETC_LEGACY', '0'],
+          },
+        })
+        checkRecords(result, 2, 3)
+      } catch (e) {
+        expect(true).toBeFalsy()
+      }
+    })
+  })
 })

package/src/functions/getProfile.ts

@@ -2,10 +2,16 @@ import { formatsByName } from '@ensdomains/address-encoder'
 import { defaultAbiCoder } from '@ethersproject/abi'
 import { isAddress } from '@ethersproject/address'
 import { hexStripZeros, isBytesLike } from '@ethersproject/bytes'
+import { GraphQLError } from 'graphql'
 import { ENSArgs } from '..'
 import { decodeContenthash, DecodedContentHash } from '../utils/contentHash'
 import { hexEncodeName } from '../utils/hexEncodedName'
 import { namehash } from '../utils/normalise'
+import {
+  ENSJSError,
+  debugSubgraphLatency,
+  getClientErrors,
+} from '../utils/errors'
 
 type InternalProfileOptions = {
   contentHash?: boolean | string | DecodedContentHash
@@ -50,6 +56,11 @@ type ResolvedProfile = {
   reverseResolverAddress?: string
 }
 
+type ResolvedProfileWithErrors = {
+  errors?: GraphQLError[]
+  result?: ResolvedProfile
+}
+
 type CallObj = {
   key: string
   data: {
@@ -359,7 +370,10 @@ const graphFetch = async (
   name: string,
   wantedRecords?: ProfileOptions,
   resolverAddress?: string,
+  skipGraph = true,
 ) => {
+  if (skipGraph) return { status: undefined, result: undefined }
+
   const query = gqlInstance.gql`
     query getRecords($id: String!) {
       domain(id: $id) {
@@ -402,29 +416,44 @@ const graphFetch = async (
 
   let domain: any
   let resolverResponse: any
-
+  let graphErrors: GraphQLError[] | undefined
   if (!resolverAddress) {
-    const response = await client.request(query, { id })
+    const response = await client
+      .request(query, { id })
+      .catch((e: unknown) => {
+        graphErrors = getClientErrors(e)
+        return undefined
+      })
+      .finally(debugSubgraphLatency)
     domain = response?.domain
     resolverResponse = domain?.resolver
   } else {
     const resolverId = `${resolverAddress.toLowerCase()}-${id}`
-    const response = await client.request(customResolverQuery, {
-      id,
-      resolverId,
-    })
+    const response = await client
+      .request(customResolverQuery, {
+        id,
+        resolverId,
+      })
+      .catch((e: unknown) => {
+        graphErrors = getClientErrors(e)
+        return undefined
+      })
+      .finally(debugSubgraphLatency)
     resolverResponse = response?.resolver
     domain = response?.domain
   }
 
-  if (!domain) return
+  if (!domain) return { errors: graphErrors }
 
   const { isMigrated, createdAt, name: decryptedName } = domain
 
   const returnedRecords: ProfileResponse = {}
 
   if (!resolverResponse || !wantedRecords)
-    return { isMigrated, createdAt, decryptedName }
+    return {
+      errors: graphErrors,
+      result: { isMigrated, createdAt, decryptedName },
+    }
 
   Object.keys(wantedRecords).forEach((key: string) => {
     const data = wantedRecords[key as keyof ProfileOptions]
@@ -438,10 +467,13 @@ const graphFetch = async (
   })
 
   return {
-    ...returnedRecords,
-    decryptedName,
-    isMigrated,
-    createdAt,
+    errors: graphErrors,
+    result: {
+      ...returnedRecords,
+      decryptedName,
+      isMigrated,
+      createdAt,
+    },
   }
 }
 
@@ -454,6 +486,7 @@ type ProfileOptions = {
 type InputProfileOptions = ProfileOptions & {
   resolverAddress?: string
   fallback?: FallbackRecords
+  skipGraph?: boolean
 }
 
 const getProfileFromName = async (
@@ -476,8 +509,8 @@ const getProfileFromName = async (
   >,
   name: string,
   options?: InputProfileOptions,
-): Promise<ResolvedProfile | undefined> => {
-  const { resolverAddress, fallback, ..._options } = options || {}
+): Promise<ResolvedProfileWithErrors> => {
+  const { resolverAddress, fallback, skipGraph, ..._options } = options || {}
   const optsLength = Object.keys(_options).length
   let usingOptions: InputProfileOptions | undefined
   if (!optsLength || _options?.texts === true || _options?.coinTypes === true) {
@@ -485,18 +518,20 @@ const getProfileFromName = async (
     else usingOptions = { contentHash: true, texts: true, coinTypes: true }
   }
 
-  const graphResult = await graphFetch(
+  const { errors, result: graphResult } = await graphFetch(
     { gqlInstance },
     name,
     usingOptions,
     resolverAddress,
+    !!skipGraph,
   )
+
   let isMigrated: boolean | null = null
   let createdAt: string | null = null
   let decryptedName: string | null = null
   let result: Awaited<ReturnType<typeof getDataForName>> | null = null
   if (!graphResult) {
-    if (!fallback) return
+    if (!fallback) return { errors }
     result = await getDataForName(
       {
         contracts,
@@ -552,13 +587,25 @@ const getProfileFromName = async (
   }
   if (!result?.resolverAddress)
     return {
+      errors,
+      result: {
+        isMigrated,
+        createdAt,
+        message: !result
+          ? "Records fetch didn't complete"
+          : "Name doesn't have a resolver",
+      },
+    }
+  return {
+    errors,
+    result: {
+      ...result,
       isMigrated,
       createdAt,
-      message: !result
-        ? "Records fetch didn't complete"
-        : "Name doesn't have a resolver",
-    }
-  return { ...result, isMigrated, createdAt, decryptedName, message: undefined }
+      decryptedName,
+      message: undefined,
+    },
+  }
 }
 
 const getProfileFromAddress = async (
@@ -583,16 +630,19 @@ const getProfileFromAddress = async (
   >,
   address: string,
   options?: InputProfileOptions,
-) => {
+): Promise<ResolvedProfileWithErrors> => {
   let name
   try {
     name = await getName(address)
   } catch (e) {
-    return
+    return {}
   }
-  if (!name || !name.name || name.name === '') return
-  if (!name.match) return { ...name, isMigrated: null, createdAt: null }
-  const result = await getProfileFromName(
+  if (!name || !name.name || name.name === '') return {}
+  if (!name.match)
+    return {
+      result: { ...name, isMigrated: null, createdAt: null },
+    }
+  const { errors, result } = await getProfileFromName(
     {
       contracts,
       gqlInstance,
@@ -605,12 +655,15 @@ const getProfileFromAddress = async (
     name.name,
     options,
   )
-  if (!result || result.message) return
+  if (!result || result.message) return { errors }
   delete (result as any).address
   return {
-    ...result,
-    ...name,
-    message: undefined,
+    errors,
+    result: {
+      ...result,
+      ...name,
+      message: undefined,
+    },
   }
 }
 
@@ -656,7 +709,7 @@ export default async function (
   const inputIsAddress = isAddress(nameOrAddress)
 
   if (inputIsAddress) {
-    return getProfileFromAddress(
+    const { errors, result } = await getProfileFromAddress(
       {
         contracts,
         gqlInstance,
@@ -670,9 +723,11 @@ export default async function (
       nameOrAddress,
       options,
     )
+    if (errors) throw new ENSJSError({ data: result, errors })
+    return result
   }
 
-  return getProfileFromName(
+  const { errors, result } = await getProfileFromName(
     {
       contracts,
       gqlInstance,
@@ -685,4 +740,6 @@ export default async function (
     nameOrAddress,
     options,
   )
+  if (errors) throw new ENSJSError({ data: result, errors })
+  return result
 }

package/src/functions/getSubnames.test.ts

@@ -1,7 +1,10 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
+import { ENSJSError } from '../utils/errors'
 import { decodeFuses } from '../utils/fuses'
 
+type Result = Awaited<ReturnType<ENS['getSubnames']>>
+
 let ensInstance: ENS
 
 beforeAll(async () => {
@@ -1577,4 +1580,36 @@ describe('getSubnames', () => {
       })
     })
   })
+
+  describe(' errors', () => {
+    beforeAll(() => {
+      process.env.NEXT_PUBLIC_ENSJS_DEBUG = 'on'
+      localStorage.setItem('ensjs-debug', 'ENSJSSubgraphError')
+    })
+
+    afterAll(() => {
+      process.env.NEXT_PUBLIC_ENSJS_DEBUG = ''
+      localStorage.removeItem('ensjs-debug')
+    })
+
+    it('should throw an error with no data if ensjs-debug is set to ENSJSUknownError', async () => {
+      try {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 10,
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+        })
+        expect(result).toBeFalsy()
+      } catch (e) {
+        expect(e).toBeInstanceOf(ENSJSError)
+        const error = e as ENSJSError<Result>
+        expect(error.name).toBe('ENSJSSubgraphError')
+        expect(error.data).toEqual({
+          subnames: [],
+          subnameCount: 0,
+        })
+      }
+    })
+  })
 })