@human-protocol/sdk 5.0.0 → 5.1.0

package/src/transaction.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { ethers } from 'ethers';
-import gqlFetch from 'graphql-request';
 import { NETWORKS } from './constants';
 import { ChainId, OrderDirection } from './enums';
 import {
@@ -17,8 +16,9 @@ import {
   InternalTransaction,
   ITransaction,
   ITransactionsFilter,
+  SubgraphOptions,
 } from './interfaces';
-import { getSubgraphUrl, getUnixTimestamp } from './utils';
+import { getSubgraphUrl, getUnixTimestamp, customGqlFetch } from './utils';
 
 export class TransactionUtils {
   /**
@@ -54,6 +54,7 @@ export class TransactionUtils {
    *
    * @param {ChainId} chainId The chain ID.
    * @param {string} hash The transaction hash.
+   * @param {SubgraphOptions} options Optional configuration for subgraph requests.
    * @returns {Promise<ITransaction | null>} - Returns the transaction details or null if not found.
    *
    * **Code example**
@@ -66,7 +67,8 @@ export class TransactionUtils {
    */
   public static async getTransaction(
     chainId: ChainId,
-    hash: string
+    hash: string,
+    options?: SubgraphOptions
   ): Promise<ITransaction | null> {
     if (!ethers.isHexString(hash)) {
       throw ErrorInvalidHashProvided;
@@ -77,11 +79,16 @@ export class TransactionUtils {
       throw ErrorUnsupportedChainID;
     }
 
-    const { transaction } = await gqlFetch<{
+    const { transaction } = await customGqlFetch<{
       transaction: TransactionData | null;
-    }>(getSubgraphUrl(networkData), GET_TRANSACTION_QUERY, {
-      hash: hash.toLowerCase(),
-    });
+    }>(
+      getSubgraphUrl(networkData),
+      GET_TRANSACTION_QUERY,
+      {
+        hash: hash.toLowerCase(),
+      },
+      options
+    );
     if (!transaction) return null;
 
     return mapTransaction(transaction);
@@ -141,6 +148,7 @@ export class TransactionUtils {
    * ```
    *
    * @param {ITransactionsFilter} filter Filter for the transactions.
+   * @param {SubgraphOptions} options Optional configuration for subgraph requests.
    * @returns {Promise<ITransaction[]>} Returns an array with all the transaction details.
    *
    * **Code example**
@@ -160,7 +168,8 @@ export class TransactionUtils {
    * ```
    */
   public static async getTransactions(
-    filter: ITransactionsFilter
+    filter: ITransactionsFilter,
+    options?: SubgraphOptions
   ): Promise<ITransaction[]> {
     if (
       (!!filter.startDate || !!filter.endDate) &&
@@ -179,24 +188,29 @@ export class TransactionUtils {
       throw ErrorUnsupportedChainID;
     }
 
-    const { transactions } = await gqlFetch<{
+    const { transactions } = await customGqlFetch<{
       transactions: TransactionData[];
-    }>(getSubgraphUrl(networkData), GET_TRANSACTIONS_QUERY(filter), {
-      fromAddress: filter?.fromAddress,
-      toAddress: filter?.toAddress,
-      startDate: filter?.startDate
-        ? getUnixTimestamp(filter?.startDate)
-        : undefined,
-      endDate: filter.endDate ? getUnixTimestamp(filter.endDate) : undefined,
-      startBlock: filter.startBlock ? filter.startBlock : undefined,
-      endBlock: filter.endBlock ? filter.endBlock : undefined,
-      method: filter.method ? filter.method : undefined,
-      escrow: filter.escrow ? filter.escrow : undefined,
-      token: filter.token ? filter.token : undefined,
-      orderDirection: orderDirection,
-      first: first,
-      skip: skip,
-    });
+    }>(
+      getSubgraphUrl(networkData),
+      GET_TRANSACTIONS_QUERY(filter),
+      {
+        fromAddress: filter?.fromAddress,
+        toAddress: filter?.toAddress,
+        startDate: filter?.startDate
+          ? getUnixTimestamp(filter?.startDate)
+          : undefined,
+        endDate: filter.endDate ? getUnixTimestamp(filter.endDate) : undefined,
+        startBlock: filter.startBlock ? filter.startBlock : undefined,
+        endBlock: filter.endBlock ? filter.endBlock : undefined,
+        method: filter.method ? filter.method : undefined,
+        escrow: filter.escrow ? filter.escrow : undefined,
+        token: filter.token ? filter.token : undefined,
+        orderDirection: orderDirection,
+        first: first,
+        skip: skip,
+      },
+      options
+    );
 
     if (!transactions) {
       return [];

package/src/utils.ts

@@ -1,11 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { ethers } from 'ethers';
+import gqlFetch from 'graphql-request';
 
 import { isURL } from 'validator';
 import { SUBGRAPH_API_KEY_PLACEHOLDER } from './constants';
 import { ChainId } from './enums';
 import {
   ContractExecutionError,
+  ErrorRetryParametersMissing,
   EthereumError,
   InvalidArgumentError,
   NonceExpired,
@@ -15,6 +17,7 @@ import {
   WarnSubgraphApiKeyNotProvided,
 } from './error';
 import { NetworkData } from './types';
+import { SubgraphOptions } from './interfaces';
 
 /**
  * **Handle and throw the error.*
@@ -99,3 +102,64 @@ export const getSubgraphUrl = (networkData: NetworkData) => {
 export const getUnixTimestamp = (date: Date): number => {
   return Math.floor(date.getTime() / 1000);
 };
+
+export const isIndexerError = (error: any): boolean => {
+  if (!error) return false;
+
+  const errorMessage =
+    error.response?.errors?.[0]?.message ||
+    error.message ||
+    error.toString() ||
+    '';
+  return errorMessage.toLowerCase().includes('bad indexers');
+};
+
+const sleep = (ms: number): Promise<void> => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+
+/**
+ * Execute a GraphQL request with automatic retry logic for bad indexer errors.
+ * Only retries if options is provided.
+ */
+export const customGqlFetch = async <T = any>(
+  url: string,
+  query: any,
+  variables?: any,
+  options?: SubgraphOptions
+): Promise<T> => {
+  if (!options) {
+    return await gqlFetch<T>(url, query, variables);
+  }
+
+  if (
+    (options.maxRetries && options.baseDelay === undefined) ||
+    (options.baseDelay && options.maxRetries === undefined)
+  ) {
+    throw ErrorRetryParametersMissing;
+  }
+
+  let lastError: any;
+
+  for (let attempt = 0; attempt <= (options.maxRetries as number); attempt++) {
+    try {
+      const result = await gqlFetch<T>(url, query, variables);
+      return result;
+    } catch (error) {
+      lastError = error;
+
+      if (attempt === options.maxRetries) {
+        throw error;
+      }
+
+      if (!isIndexerError(error)) {
+        throw error;
+      }
+
+      const delay = (options.baseDelay as number) * attempt;
+      await sleep(delay);
+    }
+  }
+
+  throw lastError;
+};

package/src/worker.ts

@@ -1,12 +1,11 @@
 import { ethers } from 'ethers';
-import gqlFetch from 'graphql-request';
 import { NETWORKS } from './constants';
 import { ChainId, OrderDirection } from './enums';
 import { ErrorInvalidAddress, ErrorUnsupportedChainID } from './error';
 import { WorkerData } from './graphql';
 import { GET_WORKER_QUERY, GET_WORKERS_QUERY } from './graphql/queries/worker';
-import { IWorker, IWorkersFilter } from './interfaces';
-import { getSubgraphUrl } from './utils';
+import { IWorker, IWorkersFilter, SubgraphOptions } from './interfaces';
+import { getSubgraphUrl, customGqlFetch } from './utils';
 
 export class WorkerUtils {
   /**
@@ -14,6 +13,7 @@ export class WorkerUtils {
    *
    * @param {ChainId} chainId The chain ID.
    * @param {string} address The worker address.
+   * @param {SubgraphOptions} options Optional configuration for subgraph requests.
    * @returns {Promise<IWorker | null>} - Returns the worker details or null if not found.
    *
    * **Code example**
@@ -26,7 +26,8 @@ export class WorkerUtils {
    */
   public static async getWorker(
     chainId: ChainId,
-    address: string
+    address: string,
+    options?: SubgraphOptions
   ): Promise<IWorker | null> {
     const networkData = NETWORKS[chainId];
 
@@ -37,11 +38,16 @@ export class WorkerUtils {
       throw ErrorInvalidAddress;
     }
 
-    const { worker } = await gqlFetch<{
+    const { worker } = await customGqlFetch<{
       worker: WorkerData | null;
-    }>(getSubgraphUrl(networkData), GET_WORKER_QUERY, {
-      address: address.toLowerCase(),
-    });
+    }>(
+      getSubgraphUrl(networkData),
+      GET_WORKER_QUERY,
+      {
+        address: address.toLowerCase(),
+      },
+      options
+    );
 
     if (!worker) return null;
 
@@ -74,6 +80,7 @@ export class WorkerUtils {
    * ```
    *
    * @param {IWorkersFilter} filter Filter for the workers.
+   * @param {SubgraphOptions} options Optional configuration for subgraph requests.
    * @returns {Promise<IWorker[]>} Returns an array with all the worker details.
    *
    * **Code example**
@@ -89,7 +96,10 @@ export class WorkerUtils {
    * const workers = await WorkerUtils.getWorkers(filter);
    * ```
    */
-  public static async getWorkers(filter: IWorkersFilter): Promise<IWorker[]> {
+  public static async getWorkers(
+    filter: IWorkersFilter,
+    options?: SubgraphOptions
+  ): Promise<IWorker[]> {
     const first =
       filter.first !== undefined ? Math.min(filter.first, 1000) : 10;
     const skip = filter.skip || 0;
@@ -104,15 +114,20 @@ export class WorkerUtils {
       throw ErrorInvalidAddress;
     }
 
-    const { workers } = await gqlFetch<{
+    const { workers } = await customGqlFetch<{
       workers: WorkerData[];
-    }>(getSubgraphUrl(networkData), GET_WORKERS_QUERY(filter), {
-      address: filter?.address?.toLowerCase(),
-      first: first,
-      skip: skip,
-      orderBy: orderBy,
-      orderDirection: orderDirection,
-    });
+    }>(
+      getSubgraphUrl(networkData),
+      GET_WORKERS_QUERY(filter),
+      {
+        address: filter?.address?.toLowerCase(),
+        first: first,
+        skip: skip,
+        orderBy: orderBy,
+        orderDirection: orderDirection,
+      },
+      options
+    );
 
     if (!workers) {
       return [];