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

package/dist/esm/functions/batch.mjs

@@ -1,4 +1,5 @@
 // src/functions/batch.ts
+import { ENSJSError } from "../utils/errors.mjs";
 var raw = async ({ multicallWrapper }, ...items) => {
   const rawDataArr = await Promise.all(
     items.map(({ args, raw: rawRef }, i) => {
@@ -15,7 +16,7 @@ var decode = async ({ multicallWrapper }, data, passthrough, ...items) => {
   const response = await multicallWrapper.decode(data, passthrough);
   if (!response)
     return;
-  return Promise.all(
+  const results = await Promise.allSettled(
     response.map((ret, i) => {
       if (passthrough[i].passthrough) {
         return items[i].decode(
@@ -27,6 +28,27 @@ var decode = async ({ multicallWrapper }, data, passthrough, ...items) => {
       return items[i].decode(ret.returnData, ...items[i].args);
     })
   );
+  const reducedResults = results.reduce(
+    (acc, result) => {
+      if (result.status === "fulfilled") {
+        return { ...acc, data: [...acc.data, result.value] };
+      }
+      const error = result.reason instanceof ENSJSError ? result.reason : void 0;
+      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;
 };
 var batch_default = {
   raw,

package/dist/esm/functions/getHistory.mjs

@@ -2,6 +2,11 @@
 import { formatsByCoinType } from "@ensdomains/address-encoder";
 import { hexStripZeros } from "@ethersproject/bytes";
 import { decodeContenthash } from "../utils/contentHash.mjs";
+import {
+  debugSubgraphLatency,
+  ENSJSError,
+  getClientErrors
+} from "../utils/errors.mjs";
 import { namehash } from "../utils/normalise.mjs";
 import { checkIsDotEth } from "../utils/validation.mjs";
 var eventFormat = {
@@ -209,14 +214,16 @@ async function getHistory({ gqlInstance }, name) {
   const is2ldEth = checkIsDotEth(labels);
   const response = await client.request(query, {
     namehash: nameHash
-  });
+  }).catch((e) => {
+    throw new ENSJSError({
+      errors: getClientErrors(e)
+    });
+  }).finally(debugSubgraphLatency);
   const domain = response?.domain;
   if (!domain)
-    return;
-  const {
-    events: domainEvents,
-    resolver: { events: resolverEvents }
-  } = domain;
+    return void 0;
+  const domainEvents = domain.events || [];
+  const resolverEvents = domain.resolver?.events || [];
   const domainHistory = mapEvents(domainEvents, "Domain");
   const resolverHistory = mapEvents(
     resolverEvents.filter(
@@ -225,9 +232,7 @@ async function getHistory({ gqlInstance }, name) {
     "Resolver"
   );
   if (is2ldEth) {
-    const {
-      registration: { events: registrationEvents }
-    } = domain;
+    const registrationEvents = domain.registration?.events || [];
     const registrationHistory = mapEvents(registrationEvents, "Registration");
     return {
       domain: domainHistory,

package/dist/esm/functions/getNames.mjs

@@ -1,4 +1,9 @@
 // src/functions/getNames.ts
+import {
+  getClientErrors,
+  ENSJSError,
+  debugSubgraphLatency
+} from "../utils/errors.mjs";
 import { truncateFormat } from "../utils/format.mjs";
 import { checkPCCBurned, decodeFuses } from "../utils/fuses.mjs";
 import { decryptName } from "../utils/labels.mjs";
@@ -361,10 +366,16 @@ var getNames = async ({ gqlInstance }, {
       expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
     };
   }
-  const response = await client.request(finalQuery, queryVars);
+  const response = await client.request(finalQuery, queryVars).catch((e) => {
+    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) => d) || []
@@ -380,6 +391,7 @@ var getNames = async ({ gqlInstance }, {
       }
       return a.createdAt.getTime() - b.createdAt.getTime();
     });
+    return data;
   }
   if (type === "resolvedAddress") {
     return response?.domains.map(mapResolvedAddress).filter((d) => d) || [];

package/dist/esm/functions/getOwner.mjs

@@ -4,6 +4,11 @@ import { hexStripZeros } from "@ethersproject/bytes";
 import { labelhash } from "../utils/labels.mjs";
 import { namehash as makeNamehash } from "../utils/normalise.mjs";
 import { checkIsDotEth } from "../utils/validation.mjs";
+import {
+  debugSubgraphLatency,
+  getClientErrors,
+  ENSJSError
+} from "../utils/errors.mjs";
 var singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels) => {
   switch (contract) {
     case "nameWrapper": {
@@ -31,7 +36,8 @@ var singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels) =
     }
   }
 };
-var raw = async ({ contracts, multicallWrapper }, name, contract) => {
+var raw = async ({ contracts, multicallWrapper }, name, options = {}) => {
+  const { contract } = options;
   const namehash = makeNamehash(name);
   const labels = name.split(".");
   if (contract || labels.length === 1) {
@@ -82,10 +88,13 @@ var decode = async ({
   contracts,
   multicallWrapper,
   gqlInstance
-}, data, name, contract) => {
+}, data, name, options = {}) => {
   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 = {
@@ -113,48 +122,85 @@ var decode = async ({
   const nameWrapperOwner = decodedData[1][0];
   let registrarOwner = decodedData[2]?.[0];
   let baseReturnObject = {};
-  if (labels[labels.length - 1] === "eth") {
-    if (labels.length === 2) {
-      if (!registrarOwner) {
-        const graphRegistrantResult = await gqlInstance.client.request(
-          registrantQuery,
-          {
-            namehash: makeNamehash(name)
-          }
-        );
-        registrarOwner = graphRegistrantResult.domain?.registration?.registrant?.id;
+  if (isEth) {
+    let graphErrors;
+    if (is2LD) {
+      if (!registrarOwner && !skipGraph) {
+        const graphRegistrantResult = await gqlInstance.client.request(registrantQuery, {
+          namehash: makeNamehash(name)
+        }).catch((e) => {
+          console.error(e);
+          graphErrors = getClientErrors(e);
+          return void 0;
+        }).finally(debugSubgraphLatency);
+        registrarOwner = graphRegistrantResult?.domain?.registration?.registrant?.id;
         baseReturnObject = {
           expired: true
         };
       } else {
         baseReturnObject = {
-          expired: false
+          expired: !registrarOwner
         };
       }
     }
+    if (baseReturnObject.expired && registryOwner?.toLowerCase() === nameWrapper.address.toLowerCase()) {
+      const owner = {
+        owner: nameWrapperOwner,
+        ownershipLevel: "nameWrapper",
+        ...baseReturnObject
+      };
+      if (graphErrors) {
+        throw new ENSJSError({
+          data: owner,
+          errors: graphErrors
+        });
+      }
+      return owner;
+    }
     if (registrarOwner?.toLowerCase() === nameWrapper.address.toLowerCase()) {
-      return {
+      const owner = {
         owner: nameWrapperOwner,
         ownershipLevel: "nameWrapper",
         ...baseReturnObject
       };
+      if (graphErrors) {
+        throw new ENSJSError({
+          data: owner,
+          errors: graphErrors
+        });
+      }
+      return owner;
     }
     if (registrarOwner) {
-      return {
+      const owner = {
         registrant: registrarOwner,
         owner: registryOwner,
         ownershipLevel: "registrar",
         ...baseReturnObject
       };
+      if (graphErrors) {
+        throw new ENSJSError({
+          data: owner,
+          errors: graphErrors
+        });
+      }
+      return owner;
     }
     if (hexStripZeros(registryOwner) !== "0x") {
       if (labels.length === 2) {
-        return {
+        const owner = {
           registrant: void 0,
           owner: registryOwner,
           ownershipLevel: "registrar",
           expired: true
         };
+        if (graphErrors) {
+          throw new ENSJSError({
+            data: owner,
+            errors: graphErrors
+          });
+        }
+        return owner;
       }
       if (registryOwner === nameWrapper.address && nameWrapperOwner && hexStripZeros(nameWrapperOwner) !== "0x") {
         return {
@@ -167,7 +213,12 @@ var decode = async ({
         ownershipLevel: "registry"
       };
     }
-    return;
+    if (graphErrors) {
+      throw new ENSJSError({
+        errors: graphErrors
+      });
+    }
+    return void 0;
   }
   if (registryOwner === nameWrapper.address && nameWrapperOwner && hexStripZeros(nameWrapperOwner) !== "0x") {
     return {

package/dist/esm/functions/getProfile.mjs

@@ -6,6 +6,11 @@ import { hexStripZeros, isBytesLike } from "@ethersproject/bytes";
 import { decodeContenthash } from "../utils/contentHash.mjs";
 import { hexEncodeName } from "../utils/hexEncodedName.mjs";
 import { namehash } from "../utils/normalise.mjs";
+import {
+  ENSJSError,
+  debugSubgraphLatency,
+  getClientErrors
+} from "../utils/errors.mjs";
 var makeMulticallData = async ({
   _getAddr,
   _getContentHash,
@@ -225,7 +230,9 @@ var getDataForName = async ({
     resolverAddress
   };
 };
-var graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress) => {
+var graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress, skipGraph = true) => {
+  if (skipGraph)
+    return { status: void 0, result: void 0 };
   const query = gqlInstance.gql`
     query getRecords($id: String!) {
       domain(id: $id) {
@@ -264,8 +271,12 @@ var graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress) =
   const id = namehash(name);
   let domain;
   let resolverResponse;
+  let graphErrors;
   if (!resolverAddress) {
-    const response = await client.request(query, { id });
+    const response = await client.request(query, { id }).catch((e) => {
+      graphErrors = getClientErrors(e);
+      return void 0;
+    }).finally(debugSubgraphLatency);
     domain = response?.domain;
     resolverResponse = domain?.resolver;
   } else {
@@ -273,16 +284,22 @@ var graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress) =
     const response = await client.request(customResolverQuery, {
       id,
       resolverId
-    });
+    }).catch((e) => {
+      graphErrors = getClientErrors(e);
+      return void 0;
+    }).finally(debugSubgraphLatency);
     resolverResponse = response?.resolver;
     domain = response?.domain;
   }
   if (!domain)
-    return;
+    return { errors: graphErrors };
   const { isMigrated, createdAt, name: decryptedName } = domain;
   const returnedRecords = {};
   if (!resolverResponse || !wantedRecords)
-    return { isMigrated, createdAt, decryptedName };
+    return {
+      errors: graphErrors,
+      result: { isMigrated, createdAt, decryptedName }
+    };
   Object.keys(wantedRecords).forEach((key) => {
     const data = wantedRecords[key];
     if (typeof data === "boolean" && data) {
@@ -294,10 +311,13 @@ var graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress) =
     }
   });
   return {
-    ...returnedRecords,
-    decryptedName,
-    isMigrated,
-    createdAt
+    errors: graphErrors,
+    result: {
+      ...returnedRecords,
+      decryptedName,
+      isMigrated,
+      createdAt
+    }
   };
 };
 var getProfileFromName = async ({
@@ -309,7 +329,7 @@ var getProfileFromName = async ({
   resolverMulticallWrapper,
   multicallWrapper
 }, name, options) => {
-  const { resolverAddress, fallback, ..._options } = options || {};
+  const { resolverAddress, fallback, skipGraph, ..._options } = options || {};
   const optsLength = Object.keys(_options).length;
   let usingOptions;
   if (!optsLength || _options?.texts === true || _options?.coinTypes === true) {
@@ -318,11 +338,12 @@ var getProfileFromName = async ({
     else
       usingOptions = { contentHash: true, texts: true, coinTypes: true };
   }
-  const graphResult = await graphFetch(
+  const { errors, result: graphResult } = await graphFetch(
     { gqlInstance },
     name,
     usingOptions,
-    resolverAddress
+    resolverAddress,
+    !!skipGraph
   );
   let isMigrated = null;
   let createdAt = null;
@@ -330,7 +351,7 @@ var getProfileFromName = async ({
   let result = null;
   if (!graphResult) {
     if (!fallback)
-      return;
+      return { errors };
     result = await getDataForName(
       {
         contracts,
@@ -374,11 +395,23 @@ var 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: void 0 };
+      decryptedName,
+      message: void 0
+    }
+  };
 };
 var getProfileFromAddress = async ({
   contracts,
@@ -394,13 +427,15 @@ var getProfileFromAddress = async ({
   try {
     name = await getName(address);
   } catch (e) {
-    return;
+    return {};
   }
   if (!name || !name.name || name.name === "")
-    return;
+    return {};
   if (!name.match)
-    return { ...name, isMigrated: null, createdAt: null };
-  const result = await getProfileFromName(
+    return {
+      result: { ...name, isMigrated: null, createdAt: null }
+    };
+  const { errors, result } = await getProfileFromName(
     {
       contracts,
       gqlInstance,
@@ -414,12 +449,15 @@ var getProfileFromAddress = async ({
     options
   );
   if (!result || result.message)
-    return;
+    return { errors };
   delete result.address;
   return {
-    ...result,
-    ...name,
-    message: void 0
+    errors,
+    result: {
+      ...result,
+      ...name,
+      message: void 0
+    }
   };
 };
 var mapCoinTypes = (coin) => {
@@ -448,7 +486,7 @@ async function getProfile_default({
   }
   const inputIsAddress = isAddress(nameOrAddress);
   if (inputIsAddress) {
-    return getProfileFromAddress(
+    const { errors: errors2, result: result2 } = await getProfileFromAddress(
       {
         contracts,
         gqlInstance,
@@ -462,8 +500,11 @@ async function getProfile_default({
       nameOrAddress,
       options
     );
+    if (errors2)
+      throw new ENSJSError({ data: result2, errors: errors2 });
+    return result2;
   }
-  return getProfileFromName(
+  const { errors, result } = await getProfileFromName(
     {
       contracts,
       gqlInstance,
@@ -476,6 +517,9 @@ async function getProfile_default({
     nameOrAddress,
     options
   );
+  if (errors)
+    throw new ENSJSError({ data: result, errors });
+  return result;
 }
 export {
   getProfile_default as default

package/dist/esm/functions/getSubnames.mjs

@@ -1,4 +1,9 @@
 // src/functions/getSubnames.ts
+import {
+  ENSJSError,
+  getClientErrors,
+  debugSubgraphLatency
+} from "../utils/errors.mjs";
 import { truncateFormat } from "../utils/format.mjs";
 import { checkPCCBurned, decodeFuses } from "../utils/fuses.mjs";
 import { decryptName } from "../utils/labels.mjs";
@@ -76,8 +81,16 @@ var largeQuery = async ({ gqlInstance }, {
     orderDirection,
     search: search?.toLowerCase()
   };
-  const response = await client.request(finalQuery, queryVars);
-  const domain = response?.domain;
+  const response = await client.request(finalQuery, queryVars).catch((e) => {
+    throw new ENSJSError({
+      data: {
+        subnames: [],
+        subnameCount: 0
+      },
+      errors: getClientErrors(e)
+    });
+  }).finally(debugSubgraphLatency);
+  const domain = response?.domain || { subdomains: [], subdomainCount: 0 };
   const subdomains = domain.subdomains.map(
     ({ wrappedDomain, ...subname }) => {
       const decrypted = decryptName(subname.name);

package/dist/esm/functions/supportsTLD.mjs

@@ -7,7 +7,7 @@ async function supportsTLD_default({ getOwner, provider }, name) {
     const tld = labels[labels.length - 1];
     if (tld === "eth")
       return true;
-    const tldOwner = await getOwner(tld, "registry");
+    const tldOwner = await getOwner(tld, { contract: "registry" });
     if (!tldOwner?.owner)
       return false;
     const dnsRegistrar = DNSRegistrar__factory.connect(

package/dist/esm/utils/errors.mjs

@@ -0,0 +1,49 @@
+// src/utils/errors.ts
+import { ClientError } from "graphql-request";
+import { GraphQLError } from "graphql";
+var ENSJSError = class extends Error {
+  name = "ENSJSSubgraphError";
+  errors;
+  data;
+  constructor({ data, errors }) {
+    super();
+    this.data = data;
+    this.errors = errors;
+  }
+};
+var getClientErrors = (e) => {
+  const error = e instanceof ClientError ? e : void 0;
+  return error?.response?.errors || [new GraphQLError("unknown_error")];
+};
+var isDebugEnvironmentActive = () => {
+  return true;
+};
+var debugSubgraphError = (request) => {
+  if (isDebugEnvironmentActive() && typeof localStorage !== "undefined" && localStorage.getItem("ensjs-debug") === "ENSJSSubgraphError") {
+    if (localStorage.getItem("subgraph-debug") === "ENSJSSubgraphIndexingError" && /_meta {/.test(request.body))
+      return;
+    throw new ClientError(
+      {
+        data: void 0,
+        errors: [new GraphQLError("ensjs-debug")],
+        status: 200
+      },
+      request
+    );
+  }
+};
+var debugSubgraphLatency = () => {
+  if (isDebugEnvironmentActive() && typeof localStorage !== "undefined" && localStorage.getItem("ensjs-debug") === "ENSJSSubgraphLatency") {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, 1e4);
+    });
+  }
+};
+export {
+  ENSJSError,
+  debugSubgraphError,
+  debugSubgraphLatency,
+  getClientErrors
+};

package/dist/types/functions/getHistory.d.ts

@@ -2,6 +2,25 @@ import { ENSArgs } from '..';
 declare type DomainEvent = 'NewOwner' | 'NewResolver' | 'Transfer' | 'NewTTL' | 'WrappedTransfer' | 'NameWrapped' | 'NameUnwrapped' | 'FusesSet' | 'ExpiryExtended';
 declare type RegistrationEvent = 'NameRegistered' | 'NameRenewed' | 'NameTransferred';
 declare type ResolverEvent = 'AddrChanged' | 'MulticoinAddrChanged' | 'NameChanged' | 'AbiChanged' | 'PubkeyChanged' | 'TextChanged' | 'ContenthashChanged' | 'InterfaceChanged' | 'AuthorisationChanged' | 'VersionChanged';
+declare type EventTypes = 'Domain' | 'Registration' | 'Resolver';
+declare type EventFormat = {
+    Domain: DomainEvent;
+    Registration: RegistrationEvent;
+    Resolver: ResolverEvent;
+};
+declare const mapEvents: <T extends EventTypes>(eventArray: any[], type: T) => {
+    type: EventFormat[T];
+    blockNumber: number;
+    transactionHash: string;
+    id: string;
+    data: object;
+}[];
+declare type MappedEvents = ReturnType<typeof mapEvents>;
+export declare type ReturnData = {
+    domain: MappedEvents;
+    registration?: MappedEvents;
+    resolver: MappedEvents;
+};
 export declare function getHistory({ gqlInstance }: ENSArgs<'gqlInstance'>, name: string): Promise<{
     domain: {
         type: DomainEvent;

package/dist/types/functions/getOwner.d.ts

@@ -1,15 +1,19 @@
 import { ENSArgs } from '..';
-declare type Owner = {
+export declare type Owner = {
     registrant?: string;
     owner?: string;
     ownershipLevel: 'nameWrapper' | 'registry' | 'registrar';
     expired?: boolean;
 };
+declare type GetOwnerOptions = {
+    contract?: 'nameWrapper' | 'registry' | 'registrar';
+    skipGraph?: boolean;
+};
 declare const _default: {
-    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
+    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, options?: GetOwnerOptions) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts, multicallWrapper, gqlInstance, }: ENSArgs<"contracts" | "gqlInstance" | "multicallWrapper">, data: string, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<Owner | undefined>;
+    decode: ({ contracts, multicallWrapper, gqlInstance, }: ENSArgs<"contracts" | "gqlInstance" | "multicallWrapper">, data: string, name: string, options?: GetOwnerOptions) => Promise<Owner | undefined>;
 };
 export default _default;

package/dist/types/functions/getProfile.d.ts

@@ -36,6 +36,7 @@ declare type ProfileOptions = {
 declare type InputProfileOptions = ProfileOptions & {
     resolverAddress?: string;
     fallback?: FallbackRecords;
+    skipGraph?: boolean;
 };
 export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: InputProfileOptions): Promise<ResolvedProfile | undefined>;
 export {};

package/dist/types/functions/getSubnames.d.ts

@@ -22,6 +22,10 @@ declare type WrappedSubname = BaseSubname & {
     type: 'wrappedDomain';
 };
 declare type Subname = WrappedSubname | UnwrappedSubname;
+declare type ReturnData = {
+    subnames: Subname[];
+    subnameCount: number;
+};
 declare type Params = {
     name: string;
     page?: number;
@@ -31,8 +35,5 @@ declare type Params = {
     lastSubnames?: Array<any>;
     search?: string;
 };
-declare const getSubnames: (injected: ENSArgs<'gqlInstance'>, functionArgs: Params) => Promise<{
-    subnames: Subname[];
-    subnameCount: number;
-}>;
+declare const getSubnames: (injected: ENSArgs<'gqlInstance'>, functionArgs: Params) => Promise<ReturnData>;
 export default getSubnames;