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

package/dist/types/index.d.ts

@@ -155,6 +155,7 @@ export declare class ENS {
             texts?: string[] | undefined;
             coinTypes?: string[] | undefined;
         } | undefined;
+        skipGraph?: boolean | undefined;
     }) | undefined) => Promise<{
         isMigrated: boolean | null;
         createdAt: string | null;
@@ -392,16 +393,17 @@ export declare class ENS {
         } | undefined>;
     }>;
     getOwner: GeneratedRawFunction<{
-        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
+        raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, options?: {
+            contract?: "nameWrapper" | "registrar" | "registry" | undefined;
+            skipGraph?: boolean | undefined;
+        }) => Promise<{
             to: string;
             data: string;
         }>;
-        decode: ({ contracts, multicallWrapper, gqlInstance, }: ENSArgs<"contracts" | "gqlInstance" | "multicallWrapper">, data: string, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
-            registrant?: string | undefined;
-            owner?: string | undefined;
-            ownershipLevel: "nameWrapper" | "registrar" | "registry";
-            expired?: boolean | undefined;
-        } | undefined>;
+        decode: ({ contracts, multicallWrapper, gqlInstance, }: ENSArgs<"contracts" | "gqlInstance" | "multicallWrapper">, data: string, name: string, options?: {
+            contract?: "nameWrapper" | "registrar" | "registry" | undefined;
+            skipGraph?: boolean | undefined;
+        }) => Promise<import("./functions/getOwner").Owner | undefined>;
     }>;
     getExpiry: GeneratedRawFunction<{
         raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: {

package/dist/types/utils/errors.d.ts

@@ -0,0 +1,14 @@
+import { GraphQLError } from 'graphql';
+export declare type ENSJSErrorName = 'ENSJSSubgraphError';
+export declare class ENSJSError<T> extends Error {
+    name: string;
+    errors?: GraphQLError[];
+    data?: T;
+    constructor({ data, errors }: {
+        data?: T;
+        errors?: GraphQLError[];
+    });
+}
+export declare const getClientErrors: (e: unknown) => GraphQLError[];
+export declare const debugSubgraphError: (request: any) => void;
+export declare const debugSubgraphLatency: () => Promise<void> | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.62",
+  "version": "3.0.0-alpha.64",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",

package/src/GqlManager.test.ts

@@ -1,5 +1,6 @@
 import { parse, print, visit } from 'graphql'
 import traverse from 'traverse'
+import { ClientError } from 'graphql-request'
 
 import { requestMiddleware, responseMiddleware } from './GqlManager'
 import { namehash } from './utils/normalise'
@@ -170,4 +171,20 @@ query getNames($id: ID!, $expiryDate: Int) {
       )
     })
   })
+
+  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 error when reqest middleware is run', async () => {
+      expect(requestMiddleware(visit, parse, print)).toThrow(ClientError)
+    })
+  })
 })

package/src/GqlManager.ts

@@ -7,6 +7,7 @@ import type {
 } from 'graphql'
 import type { gql, GraphQLClient } from 'graphql-request'
 import type Traverse from 'traverse'
+import { debugSubgraphError } from './utils/errors'
 import { namehash } from './utils/normalise'
 
 const generateSelection = (selection: any) => ({
@@ -42,6 +43,9 @@ export const enter = (node: SelectionSetNode) => {
 export const requestMiddleware =
   (visit: typeof Visit, parse: typeof Parse, print: typeof Print) =>
   (request: any) => {
+    // Debug here because response middleware will resolve any error thrown
+    debugSubgraphError(request)
+
     const requestBody = JSON.parse(request.body)
     const rawQuery = requestBody.query
     const parsedQuery = parse(rawQuery)
@@ -60,6 +64,9 @@ export const requestMiddleware =
 
 export const responseMiddleware =
   (traverse: typeof Traverse) => (response: any) => {
+    // If response is of type error, we do not need to further process it
+    if (response instanceof Error) return response
+
     // eslint-disable-next-line func-names
     traverse(response).forEach(function (responseItem: any) {
       if (responseItem instanceof Object && responseItem.name) {

package/src/functions/batch.test.ts

@@ -1,5 +1,6 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
+import { ENSJSError } from '../utils/errors'
 
 let ensInstance: ENS
 
@@ -33,4 +34,44 @@ describe('batch', () => {
       expect(result[0]).toBe('Hello2')
     }
   })
+
+  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 a single error if there is an indexing error', async () => {
+      try {
+        await ensInstance.batch(
+          ensInstance.getText.batch('with-profile.eth', 'description'),
+          ensInstance.getOwner.batch('expired.eth', { skipGraph: false }),
+          ensInstance.getName.batch(
+            '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          ),
+        )
+        expect(true).toBe(false)
+      } catch (e) {
+        expect(e).toBeInstanceOf(ENSJSError)
+        const error = e as ENSJSError<any[]>
+        expect(error.name).toBe('ENSJSSubgraphError')
+        const result = error.data as any[]
+        expect(result[0]).toBe('Hello2')
+        expect(result[1]).toEqual({
+          expired: true,
+          owner: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8',
+          ownershipLevel: 'registrar',
+        })
+        expect(result[2]).toMatchObject({
+          name: 'with-profile.eth',
+          match: true,
+        })
+      }
+    })
+  })
 })

package/src/functions/batch.ts

@@ -1,5 +1,6 @@
 import { TransactionRequest } from '@ethersproject/abstract-provider'
 import { BatchFunctionResult, ENSArgs, RawFunction } from '..'
+import { ENSJSError } from '../utils/errors'
 
 const raw = async (
   { multicallWrapper }: ENSArgs<'multicallWrapper'>,
@@ -26,7 +27,7 @@ const decode = async (
   const response = await multicallWrapper.decode(data, passthrough)
   if (!response) return
 
-  return Promise.all(
+  const results = await Promise.allSettled(
     response.map((ret: any, i: number) => {
       if (passthrough[i].passthrough) {
         return items[i].decode(
@@ -38,6 +39,35 @@ const decode = async (
       return items[i].decode(ret.returnData, ...items[i].args)
     }),
   )
+
+  const reducedResults = results.reduce<{
+    errors: any[]
+    data: any[]
+  }>(
+    (acc, result) => {
+      if (result.status === 'fulfilled') {
+        return { ...acc, data: [...acc.data, result.value] }
+      }
+      const error =
+        result.reason instanceof ENSJSError
+          ? (result.reason as ENSJSError<any>)
+          : undefined
+      const itemData = error?.data
+      const itemErrors = error?.errors || [{ message: 'unknown_error' }]
+      return {
+        errors: [...acc.errors, ...itemErrors],
+        data: [...acc.data, itemData],
+      }
+    },
+    { data: [], errors: [] },
+  )
+
+  if (reducedResults.errors.length)
+    throw new ENSJSError({
+      data: reducedResults.data,
+      errors: reducedResults.errors,
+    })
+  return reducedResults.data
 }
 
 export default {

package/src/functions/getHistory.test.ts

@@ -1,5 +1,7 @@
 import { ENS } from '..'
 import setup from '../tests/setup'
+import { ENSJSError } from '../utils/errors'
+import { ReturnData } from './getHistory'
 
 let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -46,4 +48,27 @@ describe('getHistory', () => {
       expect(result).not.toHaveProperty('registration')
     }
   })
+
+  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', async () => {
+      try {
+        await ensInstance.getHistory('with-profile.eth')
+        expect(true).toBeFalsy()
+      } catch (e) {
+        expect(e).toBeInstanceOf(ENSJSError)
+        const error = e as ENSJSError<ReturnData>
+        expect(error.data).toBeUndefined()
+      }
+    })
+  })
 })

package/src/functions/getHistory.ts

@@ -2,6 +2,11 @@ import { formatsByCoinType } from '@ensdomains/address-encoder'
 import { hexStripZeros } from '@ethersproject/bytes'
 import { ENSArgs } from '..'
 import { decodeContenthash } from '../utils/contentHash'
+import {
+  debugSubgraphLatency,
+  ENSJSError,
+  getClientErrors,
+} from '../utils/errors'
 import { namehash } from '../utils/normalise'
 import {
   AbiChanged,
@@ -148,6 +153,14 @@ const mapEvents = <T extends EventTypes>(eventArray: any[], type: T) =>
     }),
   )
 
+type MappedEvents = ReturnType<typeof mapEvents>
+
+export type ReturnData = {
+  domain: MappedEvents
+  registration?: MappedEvents
+  resolver: MappedEvents
+}
+
 export async function getHistory(
   { gqlInstance }: ENSArgs<'gqlInstance'>,
   name: string,
@@ -279,17 +292,23 @@ export async function getHistory(
   const labels = name.split('.')
   const is2ldEth = checkIsDotEth(labels)
 
-  const response = await client.request(query, {
-    namehash: nameHash,
-  })
+  const response = await client
+    .request(query, {
+      namehash: nameHash,
+    })
+    .catch((e: unknown) => {
+      throw new ENSJSError({
+        errors: getClientErrors(e),
+      })
+    })
+    .finally(debugSubgraphLatency)
+
   const domain = response?.domain
 
-  if (!domain) return
+  if (!domain) return undefined
 
-  const {
-    events: domainEvents,
-    resolver: { events: resolverEvents },
-  } = domain
+  const domainEvents = domain.events || []
+  const resolverEvents = domain.resolver?.events || []
 
   const domainHistory = mapEvents(domainEvents, 'Domain')
   const resolverHistory = mapEvents(
@@ -301,9 +320,7 @@ export async function getHistory(
   )
 
   if (is2ldEth) {
-    const {
-      registration: { events: registrationEvents },
-    } = domain
+    const registrationEvents = domain.registration?.events || []
     const registrationHistory = mapEvents(registrationEvents, 'Registration')
     return {
       domain: domainHistory,

package/src/functions/getNames.test.ts

@@ -4,6 +4,7 @@ import { ENS } from '..'
 import setup from '../tests/setup'
 import { Name } from './getNames'
 import { names as wrappedNames } from '../../deploy/00_register_wrapped'
+import { ENSJSError } from '../utils/errors'
 
 let ensInstance: ENS
 let provider: ethers.providers.JsonRpcProvider
@@ -390,4 +391,31 @@ describe('getNames', () => {
       })
     })
   })
+
+  describe('error', () => {
+    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 ENSJSError for type "all"', async () => {
+      try {
+        await ensInstance.getNames({
+          address: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+          type: 'all',
+        })
+        expect(true).toBeFalsy()
+      } catch (e) {
+        expect(e).toBeInstanceOf(ENSJSError)
+        const error = e as ENSJSError<Name[]>
+        expect(error.name).toBe('ENSJSSubgraphError')
+        expect(error.data?.length).toBe(0)
+      }
+    })
+  })
 })

package/src/functions/getNames.ts

@@ -1,4 +1,9 @@
 import { ENSArgs } from '..'
+import {
+  getClientErrors,
+  ENSJSError,
+  debugSubgraphLatency,
+} from '../utils/errors'
 import { truncateFormat } from '../utils/format'
 import { AllCurrentFuses, checkPCCBurned, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
@@ -466,10 +471,20 @@ const getNames = async (
     }
   }
 
-  const response = await client.request(finalQuery, queryVars)
+  const response = await client
+    .request(finalQuery, queryVars)
+    .catch((e: unknown) => {
+      console.error(e)
+      throw new ENSJSError({
+        errors: getClientErrors(e),
+        data: [],
+      })
+    })
+    .finally(debugSubgraphLatency)
   const account = response?.account
+
   if (type === 'all') {
-    return [
+    const data = [
       ...(account?.domains.map(mapDomain) || []),
       ...(account?.registrations.map(mapRegistration) || []),
       ...(account?.wrappedDomains.map(mapWrappedDomain).filter((d: any) => d) ||
@@ -486,6 +501,7 @@ const getNames = async (
       }
       return a.createdAt.getTime() - b.createdAt.getTime()
     }) as Name[]
+    return data
   }
   if (type === 'resolvedAddress') {
     return (response?.domains.map(mapResolvedAddress).filter((d: any) => d) ||
@@ -499,6 +515,7 @@ const getNames = async (
       .map(mapWrappedDomain)
       .filter((d: any) => d) || []) as Name[]
   }
+
   return (account?.registrations.map(mapRegistration) || []) as Name[]
 }
 

package/src/functions/getOwner.test.ts

@@ -1,6 +1,8 @@
 import { JsonRpcProvider } from '@ethersproject/providers'
 import { ENS } from '..'
 import setup from '../tests/setup'
+import { ENSJSError } from '../utils/errors'
+import { Owner } from './getOwner'
 
 let ensInstance: ENS
 let revert: Awaited<ReturnType<typeof setup>>['revert']
@@ -17,6 +19,13 @@ afterAll(async () => {
 })
 
 describe('getOwner', () => {
+  it('should return undefined for an nonexistent .eth name', async () => {
+    const result = await ensInstance.getOwner('nonexistent.eth', {
+      skipGraph: false,
+    })
+    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({
@@ -26,7 +35,9 @@ describe('getOwner', () => {
     })
   })
   it('should return correct ownership level and values for an expired wrapped .eth name', async () => {
-    const result = await ensInstance.getOwner('expired-wrapped.eth')
+    const result = await ensInstance.getOwner('expired-wrapped.eth', {
+      skipGraph: false,
+    })
     expect(result).toEqual({
       ownershipLevel: 'nameWrapper',
       owner: '0x0000000000000000000000000000000000000000',
@@ -43,7 +54,9 @@ describe('getOwner', () => {
     })
   })
   it('should return correct ownership level and values for an expired unwrapped .eth name', async () => {
-    const result = await ensInstance.getOwner('expired.eth')
+    const result = await ensInstance.getOwner('expired.eth', {
+      skipGraph: false,
+    })
     expect(result).toEqual({
       ownershipLevel: 'registrar',
       owner: accounts[1],
@@ -51,6 +64,7 @@ describe('getOwner', () => {
       expired: true,
     })
   })
+
   describe('subname', () => {
     it('should return correct ownership level and values for a unwrapped name', async () => {
       const result = await ensInstance.getOwner('test.with-subnames.eth')
@@ -68,6 +82,7 @@ describe('getOwner', () => {
         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({
@@ -76,4 +91,148 @@ describe('getOwner', () => {
       })
     })
   })
+
+  // Only 2LDEth names need to be tested
+  describe('skipGraph', () => {
+    it('should return undefined for an nonexistent .eth name', async () => {
+      const result = await ensInstance.getOwner('nonexistent.eth', {
+        skipGraph: true,
+      })
+      expect(result).toBeUndefined()
+    })
+
+    it('should return correct ownership level and values for a wrapped .eth name', async () => {
+      const result = await ensInstance.getOwner('wrapped.eth', {
+        skipGraph: true,
+      })
+      expect(result).toEqual({
+        ownershipLevel: 'nameWrapper',
+        owner: accounts[1],
+        expired: false,
+      })
+    })
+
+    it('should return correct ownership level and values for an expired wrapped .eth name', async () => {
+      const result = await ensInstance.getOwner('expired-wrapped.eth', {
+        skipGraph: true,
+      })
+
+      expect(result).toEqual({
+        ownershipLevel: 'nameWrapper',
+        owner: '0x0000000000000000000000000000000000000000',
+        expired: true,
+      })
+    })
+
+    it('should return correct ownership level and values for an unwrapped .eth name', async () => {
+      const result = await ensInstance.getOwner('test123.eth', {
+        skipGraph: true,
+      })
+      expect(result).toEqual({
+        ownershipLevel: 'registrar',
+        owner: accounts[1],
+        registrant: accounts[1],
+        expired: false,
+      })
+    })
+
+    it('should return registrant undefined if skipGraph is true for an unwrapped .eth name', async () => {
+      const result = await ensInstance.getOwner('expired.eth', {
+        skipGraph: true,
+      })
+      expect(result).toEqual({
+        ownershipLevel: 'registrar',
+        owner: accounts[1],
+        expired: true,
+      })
+    })
+
+    it('should return correct ownership level and values for a unwrapped subname', async () => {
+      const result = await ensInstance.getOwner('test.with-subnames.eth', {
+        skipGraph: true,
+      })
+      expect(result).toEqual({
+        ownershipLevel: 'registry',
+        owner: accounts[2],
+      })
+    })
+
+    it('should return correct ownership level and values for a wrapped subname', async () => {
+      const result = await ensInstance.getOwner(
+        'test.wrapped-with-subnames.eth',
+        { skipGraph: true },
+      )
+      expect(result).toEqual({
+        ownershipLevel: 'nameWrapper',
+        owner: accounts[2],
+      })
+    })
+  })
+
+  describe('errors', () => {
+    beforeAll(() => {
+      process.env.NEXT_PUBLIC_ENSJS_DEBUG = 'on'
+      localStorage.setItem('ensjs-debug', 'ENSJSSubgraphError')
+    })
+    afterAll(() => {
+      process.env.NEXT_PUBLIC_ENS_DEBUG = 'on'
+      localStorage.removeItem('ensjs-debug')
+    })
+
+    it('should return correct ownership level and values for an expired wrapped .eth name', async () => {
+      try {
+        await ensInstance.getOwner('expired-wrapped.eth', {
+          skipGraph: false,
+        })
+        expect(true).toBeFalsy()
+      } catch (e: unknown) {
+        const error = e as ENSJSError<Owner>
+        expect(error).toBeInstanceOf(ENSJSError)
+        expect(error.name).toBe('ENSJSSubgraphError')
+        expect(error.data).toEqual({
+          owner: '0x0000000000000000000000000000000000000000',
+          ownershipLevel: 'nameWrapper',
+          expired: true,
+        })
+      }
+    })
+
+    it('should return registrant undefined for an expired unwrapped .eth name', async () => {
+      try {
+        await ensInstance.getOwner('expired.eth', { skipGraph: false })
+        expect(true).toBeFalsy()
+      } catch (e) {
+        const error = e as ENSJSError<Owner>
+        expect(error).toBeInstanceOf(ENSJSError)
+        expect(error.name).toBe('ENSJSSubgraphError')
+        expect(error.data).toEqual({
+          owner: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8',
+          ownershipLevel: 'registrar',
+          expired: true,
+        })
+      }
+    })
+
+    it('should return undefined for a name that does not exist', async () => {
+      try {
+        await ensInstance.getOwner('notexistent.eth', {
+          skipGraph: false,
+        })
+        expect(true).toBeFalsy()
+      } catch (e) {
+        const error = e as ENSJSError<Owner>
+        expect(error).toBeInstanceOf(ENSJSError)
+        expect(error.name).toBe('ENSJSSubgraphError')
+        expect(error.data).toBeUndefined()
+      }
+    })
+
+    it('should not throw error for subname eth', async () => {
+      await expect(
+        ensInstance.getOwner('test.expired-wrapped.eth', {
+          skipGraph: false,
+        }),
+      ).resolves.toBeDefined()
+    })
+  })
 })