@human-protocol/sdk 6.1.0 → 7.0.0

package/src/{staking.ts → staking/staking_client.ts}

@@ -7,10 +7,10 @@ import {
   Staking__factory,
 } from '@human-protocol/core/typechain-types';
 import { ContractRunner, ethers } from 'ethers';
-import { BaseEthersClient } from './base';
-import { NETWORKS } from './constants';
-import { requiresSigner } from './decorators';
-import { ChainId, OrderDirection } from './enums';
+import { BaseEthersClient } from '../base';
+import { NETWORKS } from '../constants';
+import { requiresSigner } from '../decorators';
+import { ChainId } from '../enums';
 import {
   ErrorEscrowAddressIsNotProvidedByFactory,
   ErrorInvalidEscrowAddressProvided,
@@ -19,22 +19,11 @@ import {
   ErrorInvalidStakingValueSign,
   ErrorInvalidStakingValueType,
   ErrorProviderDoesNotExist,
-  ErrorStakerNotFound,
   ErrorUnsupportedChainID,
-} from './error';
-import {
-  IStaker,
-  IStakersFilter,
-  StakerInfo,
-  SubgraphOptions,
-} from './interfaces';
-import { StakerData } from './graphql';
-import { NetworkData, TransactionOverrides } from './types';
-import { getSubgraphUrl, customGqlFetch, throwError } from './utils';
-import {
-  GET_STAKER_BY_ADDRESS_QUERY,
-  GET_STAKERS_QUERY,
-} from './graphql/queries/staking';
+} from '../error';
+import { StakerInfo } from '../interfaces';
+import { NetworkData, TransactionOverrides } from '../types';
+import { throwError } from '../utils';
 
 /**
  * Client for staking actions on HUMAN Protocol.
@@ -456,158 +445,3 @@ export class StakingClient extends BaseEthersClient {
     }
   }
 }
-
-/**
- * Utility helpers for Staking-related queries.
- *
- * @example
- * ```ts
- * import { StakingUtils, ChainId } from '@human-protocol/sdk';
- *
- * const staker = await StakingUtils.getStaker(
- *   ChainId.POLYGON_AMOY,
- *   '0xYourStakerAddress'
- * );
- * console.log('Staked amount:', staker.stakedAmount);
- * ```
- */
-export class StakingUtils {
-  /**
-   * Gets staking info for a staker from the subgraph.
-   *
-   * @param chainId - Network in which the staking contract is deployed
-   * @param stakerAddress - Address of the staker
-   * @param options - Optional configuration for subgraph requests.
-   * @returns Staker info from subgraph
-   * @throws ErrorInvalidStakerAddressProvided If the staker address is invalid
-   * @throws ErrorUnsupportedChainID If the chain ID is not supported
-   * @throws ErrorStakerNotFound If the staker is not found
-   *
-   * @example
-   * ```ts
-   * import { StakingUtils, ChainId } from '@human-protocol/sdk';
-   *
-   * const staker = await StakingUtils.getStaker(
-   *   ChainId.POLYGON_AMOY,
-   *   '0xYourStakerAddress'
-   * );
-   * console.log('Staked amount:', staker.stakedAmount);
-   * ```
-   */
-  public static async getStaker(
-    chainId: ChainId,
-    stakerAddress: string,
-    options?: SubgraphOptions
-  ): Promise<IStaker> {
-    if (!ethers.isAddress(stakerAddress)) {
-      throw ErrorInvalidStakerAddressProvided;
-    }
-
-    const networkData: NetworkData | undefined = NETWORKS[chainId];
-    if (!networkData) {
-      throw ErrorUnsupportedChainID;
-    }
-
-    const { staker } = await customGqlFetch<{ staker: StakerData }>(
-      getSubgraphUrl(networkData),
-      GET_STAKER_BY_ADDRESS_QUERY,
-      { id: stakerAddress.toLowerCase() },
-      options
-    );
-
-    if (!staker) {
-      throw ErrorStakerNotFound;
-    }
-
-    return mapStaker(staker);
-  }
-
-  /**
-   * Gets all stakers from the subgraph with filters, pagination and ordering.
-   *
-   * @param filter - Stakers filter with pagination and ordering
-   * @param options - Optional configuration for subgraph requests.
-   * @returns Array of stakers
-   * @throws ErrorUnsupportedChainID If the chain ID is not supported
-   *
-   * @example
-   * ```ts
-   * import { ChainId } from '@human-protocol/sdk';
-   *
-   * const filter = {
-   *   chainId: ChainId.POLYGON_AMOY,
-   *   minStakedAmount: '1000000000000000000', // 1 token in WEI
-   * };
-   * const stakers = await StakingUtils.getStakers(filter);
-   * console.log('Stakers:', stakers.length);
-   * ```
-   */
-  public static async getStakers(
-    filter: IStakersFilter,
-    options?: SubgraphOptions
-  ): Promise<IStaker[]> {
-    const first =
-      filter.first !== undefined ? Math.min(filter.first, 1000) : 10;
-    const skip = filter.skip || 0;
-    const orderDirection = filter.orderDirection || OrderDirection.DESC;
-    const orderBy = filter.orderBy || 'lastDepositTimestamp';
-
-    const networkData = NETWORKS[filter.chainId];
-    if (!networkData) {
-      throw ErrorUnsupportedChainID;
-    }
-
-    const { stakers } = await customGqlFetch<{ stakers: StakerData[] }>(
-      getSubgraphUrl(networkData),
-      GET_STAKERS_QUERY(filter),
-      {
-        minStakedAmount: filter.minStakedAmount
-          ? filter.minStakedAmount
-          : undefined,
-        maxStakedAmount: filter.maxStakedAmount
-          ? filter.maxStakedAmount
-          : undefined,
-        minLockedAmount: filter.minLockedAmount
-          ? filter.minLockedAmount
-          : undefined,
-        maxLockedAmount: filter.maxLockedAmount
-          ? filter.maxLockedAmount
-          : undefined,
-        minWithdrawnAmount: filter.minWithdrawnAmount
-          ? filter.minWithdrawnAmount
-          : undefined,
-        maxWithdrawnAmount: filter.maxWithdrawnAmount
-          ? filter.maxWithdrawnAmount
-          : undefined,
-        minSlashedAmount: filter.minSlashedAmount
-          ? filter.minSlashedAmount
-          : undefined,
-        maxSlashedAmount: filter.maxSlashedAmount
-          ? filter.maxSlashedAmount
-          : undefined,
-        orderBy: orderBy,
-        orderDirection: orderDirection,
-        first: first,
-        skip: skip,
-      },
-      options
-    );
-    if (!stakers) {
-      return [];
-    }
-
-    return stakers.map((s) => mapStaker(s));
-  }
-}
-
-function mapStaker(s: StakerData): IStaker {
-  return {
-    address: s.address,
-    stakedAmount: BigInt(s.stakedAmount),
-    lockedAmount: BigInt(s.lockedAmount),
-    withdrawableAmount: BigInt(s.withdrawnAmount),
-    slashedAmount: BigInt(s.slashedAmount),
-    lockedUntil: Number(s.lockedUntilTimestamp) * 1000,
-    lastDepositTimestamp: Number(s.lastDepositTimestamp) * 1000,
-  };
-}

package/src/staking/staking_utils.ts

@@ -0,0 +1,170 @@
+import { ethers } from 'ethers';
+import { NETWORKS } from '../constants';
+import { ChainId, OrderDirection } from '../enums';
+import {
+  ErrorInvalidStakerAddressProvided,
+  ErrorStakerNotFound,
+  ErrorUnsupportedChainID,
+} from '../error';
+import { StakerData } from '../graphql';
+import {
+  GET_STAKER_BY_ADDRESS_QUERY,
+  GET_STAKERS_QUERY,
+} from '../graphql/queries/staking';
+import { IStaker, IStakersFilter, SubgraphOptions } from '../interfaces';
+import { NetworkData } from '../types';
+import { customGqlFetch, getSubgraphUrl } from '../utils';
+/**
+ * Utility helpers for Staking-related queries.
+ *
+ * @example
+ * ```ts
+ * import { StakingUtils, ChainId } from '@human-protocol/sdk';
+ *
+ * const staker = await StakingUtils.getStaker(
+ *   ChainId.POLYGON_AMOY,
+ *   '0xYourStakerAddress'
+ * );
+ * console.log('Staked amount:', staker.stakedAmount);
+ * ```
+ */
+export class StakingUtils {
+  /**
+   * Gets staking info for a staker from the subgraph.
+   *
+   * @param chainId - Network in which the staking contract is deployed
+   * @param stakerAddress - Address of the staker
+   * @param options - Optional configuration for subgraph requests.
+   * @returns Staker info from subgraph
+   * @throws ErrorInvalidStakerAddressProvided If the staker address is invalid
+   * @throws ErrorUnsupportedChainID If the chain ID is not supported
+   * @throws ErrorStakerNotFound If the staker is not found
+   *
+   * @example
+   * ```ts
+   * import { StakingUtils, ChainId } from '@human-protocol/sdk';
+   *
+   * const staker = await StakingUtils.getStaker(
+   *   ChainId.POLYGON_AMOY,
+   *   '0xYourStakerAddress'
+   * );
+   * console.log('Staked amount:', staker.stakedAmount);
+   * ```
+   */
+  public static async getStaker(
+    chainId: ChainId,
+    stakerAddress: string,
+    options?: SubgraphOptions
+  ): Promise<IStaker> {
+    if (!ethers.isAddress(stakerAddress)) {
+      throw ErrorInvalidStakerAddressProvided;
+    }
+
+    const networkData: NetworkData | undefined = NETWORKS[chainId];
+    if (!networkData) {
+      throw ErrorUnsupportedChainID;
+    }
+
+    const { staker } = await customGqlFetch<{ staker: StakerData }>(
+      getSubgraphUrl(networkData),
+      GET_STAKER_BY_ADDRESS_QUERY,
+      { id: stakerAddress.toLowerCase() },
+      options
+    );
+
+    if (!staker) {
+      throw ErrorStakerNotFound;
+    }
+
+    return mapStaker(staker);
+  }
+
+  /**
+   * Gets all stakers from the subgraph with filters, pagination and ordering.
+   *
+   * @param filter - Stakers filter with pagination and ordering
+   * @param options - Optional configuration for subgraph requests.
+   * @returns Array of stakers
+   * @throws ErrorUnsupportedChainID If the chain ID is not supported
+   *
+   * @example
+   * ```ts
+   * import { ChainId } from '@human-protocol/sdk';
+   *
+   * const filter = {
+   *   chainId: ChainId.POLYGON_AMOY,
+   *   minStakedAmount: '1000000000000000000', // 1 token in WEI
+   * };
+   * const stakers = await StakingUtils.getStakers(filter);
+   * console.log('Stakers:', stakers.length);
+   * ```
+   */
+  public static async getStakers(
+    filter: IStakersFilter,
+    options?: SubgraphOptions
+  ): Promise<IStaker[]> {
+    const first =
+      filter.first !== undefined ? Math.min(filter.first, 1000) : 10;
+    const skip = filter.skip || 0;
+    const orderDirection = filter.orderDirection || OrderDirection.DESC;
+    const orderBy = filter.orderBy || 'lastDepositTimestamp';
+
+    const networkData = NETWORKS[filter.chainId];
+    if (!networkData) {
+      throw ErrorUnsupportedChainID;
+    }
+
+    const { stakers } = await customGqlFetch<{ stakers: StakerData[] }>(
+      getSubgraphUrl(networkData),
+      GET_STAKERS_QUERY(filter),
+      {
+        minStakedAmount: filter.minStakedAmount
+          ? filter.minStakedAmount
+          : undefined,
+        maxStakedAmount: filter.maxStakedAmount
+          ? filter.maxStakedAmount
+          : undefined,
+        minLockedAmount: filter.minLockedAmount
+          ? filter.minLockedAmount
+          : undefined,
+        maxLockedAmount: filter.maxLockedAmount
+          ? filter.maxLockedAmount
+          : undefined,
+        minWithdrawnAmount: filter.minWithdrawnAmount
+          ? filter.minWithdrawnAmount
+          : undefined,
+        maxWithdrawnAmount: filter.maxWithdrawnAmount
+          ? filter.maxWithdrawnAmount
+          : undefined,
+        minSlashedAmount: filter.minSlashedAmount
+          ? filter.minSlashedAmount
+          : undefined,
+        maxSlashedAmount: filter.maxSlashedAmount
+          ? filter.maxSlashedAmount
+          : undefined,
+        orderBy: orderBy,
+        orderDirection: orderDirection,
+        first: first,
+        skip: skip,
+      },
+      options
+    );
+    if (!stakers) {
+      return [];
+    }
+
+    return stakers.map((s) => mapStaker(s));
+  }
+}
+
+function mapStaker(s: StakerData): IStaker {
+  return {
+    address: s.address,
+    stakedAmount: BigInt(s.stakedAmount),
+    lockedAmount: BigInt(s.lockedAmount),
+    withdrawableAmount: BigInt(s.withdrawnAmount),
+    slashedAmount: BigInt(s.slashedAmount),
+    lockedUntil: Number(s.lockedUntilTimestamp) * 1000,
+    lastDepositTimestamp: Number(s.lastDepositTimestamp) * 1000,
+  };
+}

package/src/statistics/index.ts

@@ -0,0 +1 @@
+export { StatisticsUtils } from './statistics_utils';

package/src/{statistics.ts → statistics/statistics_utils.ts}

@@ -1,15 +1,17 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { OrderDirection } from './enums';
+import { OrderDirection } from '../enums';
 import {
   EscrowStatisticsData,
   EventDayData,
+  HMTEventDayData,
   GET_ESCROW_STATISTICS_QUERY,
   GET_EVENT_DAY_DATA_QUERY,
+  GET_HMT_EVENT_DAY_DATA_QUERY,
   GET_HMTOKEN_STATISTICS_QUERY,
   GET_HOLDERS_QUERY,
   HMTHolderData,
   HMTStatisticsData,
-} from './graphql';
+} from '../graphql';
 import {
   IDailyHMT,
   IEscrowStatistics,
@@ -20,14 +22,15 @@ import {
   IStatisticsFilter,
   IWorkerStatistics,
   SubgraphOptions,
-} from './interfaces';
-import { NetworkData } from './types';
+} from '../interfaces';
+import { NetworkData } from '../types';
 import {
+  getHMTSubgraphUrl,
   getSubgraphUrl,
   getUnixTimestamp,
   customGqlFetch,
   throwError,
-} from './utils';
+} from '../utils';
 
 /**
  * Utility class for statistics-related queries.
@@ -253,9 +256,7 @@ export class StatisticsUtils {
    * ```ts
    * interface IDailyPayment {
    *   timestamp: number;
-   *   totalAmountPaid: bigint;
    *   totalCount: number;
-   *   averageAmountPerWorker: bigint;
    * };
    *
    * interface IPaymentStatistics {
@@ -274,14 +275,7 @@ export class StatisticsUtils {
    *
    * const networkData = NETWORKS[ChainId.POLYGON_AMOY];
    * const paymentStats = await StatisticsUtils.getPaymentStatistics(networkData);
-   * console.log(
-   *   'Payment statistics:',
-   *   paymentStats.dailyPaymentsData.map((p) => ({
-   *     ...p,
-   *     totalAmountPaid: p.totalAmountPaid.toString(),
-   *     averageAmountPerWorker: p.averageAmountPerWorker.toString(),
-   *   }))
-   * );
+   * console.log('Payment statistics:', paymentStats.dailyPaymentsData);
    *
    * const paymentStatsRange = await StatisticsUtils.getPaymentStatistics(
    *   networkData,
@@ -323,13 +317,7 @@ export class StatisticsUtils {
       return {
         dailyPaymentsData: eventDayDatas.map((eventDayData) => ({
           timestamp: +eventDayData.timestamp * 1000,
-          totalAmountPaid: BigInt(eventDayData.dailyHMTPayoutAmount),
           totalCount: +eventDayData.dailyPayoutCount,
-          averageAmountPerWorker:
-            eventDayData.dailyWorkerCount === '0'
-              ? BigInt(0)
-              : BigInt(eventDayData.dailyHMTPayoutAmount) /
-                BigInt(eventDayData.dailyWorkerCount),
         })),
       };
     } catch (e: any) {
@@ -369,7 +357,7 @@ export class StatisticsUtils {
     options?: SubgraphOptions
   ): Promise<IHMTStatistics> {
     try {
-      const subgraphUrl = getSubgraphUrl(networkData);
+      const subgraphUrl = getHMTSubgraphUrl(networkData);
       const { hmtokenStatistics } = await customGqlFetch<{
         hmtokenStatistics: HMTStatisticsData;
       }>(subgraphUrl, GET_HMTOKEN_STATISTICS_QUERY, options);
@@ -412,7 +400,7 @@ export class StatisticsUtils {
     options?: SubgraphOptions
   ): Promise<IHMTHolder[]> {
     try {
-      const subgraphUrl = getSubgraphUrl(networkData);
+      const subgraphUrl = getHMTSubgraphUrl(networkData);
       const { address, orderDirection } = params;
       const query = GET_HOLDERS_QUERY(address);
 
@@ -490,17 +478,17 @@ export class StatisticsUtils {
     options?: SubgraphOptions
   ): Promise<IDailyHMT[]> {
     try {
-      const subgraphUrl = getSubgraphUrl(networkData);
+      const subgraphUrl = getHMTSubgraphUrl(networkData);
       const first =
         filter.first !== undefined ? Math.min(filter.first, 1000) : 10;
       const skip = filter.skip || 0;
       const orderDirection = filter.orderDirection || OrderDirection.ASC;
 
       const { eventDayDatas } = await customGqlFetch<{
-        eventDayDatas: EventDayData[];
+        eventDayDatas: HMTEventDayData[];
       }>(
         subgraphUrl,
-        GET_EVENT_DAY_DATA_QUERY(filter),
+        GET_HMT_EVENT_DAY_DATA_QUERY(filter),
         {
           from: filter.from ? getUnixTimestamp(filter.from) : undefined,
           to: filter.to ? getUnixTimestamp(filter.to) : undefined,

package/src/transaction/index.ts

@@ -0,0 +1 @@
+export { TransactionUtils } from './transaction_utils';

package/src/{transaction.ts → transaction/transaction_utils.ts}

@@ -1,23 +1,23 @@
 import { ethers } from 'ethers';
-import { NETWORKS } from './constants';
-import { ChainId, OrderDirection } from './enums';
+import { NETWORKS } from '../constants';
+import { ChainId, OrderDirection } from '../enums';
 import {
   ErrorCannotUseDateAndBlockSimultaneously,
   ErrorInvalidHashProvided,
   ErrorUnsupportedChainID,
-} from './error';
-import { TransactionData } from './graphql';
+} from '../error';
+import { TransactionData } from '../graphql';
 import {
   GET_TRANSACTION_QUERY,
   GET_TRANSACTIONS_QUERY,
-} from './graphql/queries/transaction';
+} from '../graphql/queries/transaction';
 import {
   InternalTransaction,
   ITransaction,
   ITransactionsFilter,
   SubgraphOptions,
-} from './interfaces';
-import { getSubgraphUrl, getUnixTimestamp, customGqlFetch } from './utils';
+} from '../interfaces';
+import { getSubgraphUrl, getUnixTimestamp, customGqlFetch } from '../utils';
 
 /**
  * Utility class for transaction-related queries.

package/src/types.ts

@@ -76,6 +76,14 @@ export type NetworkData = {
    * Subgraph URL API key
    */
   subgraphUrlApiKey: string;
+  /**
+   * HMT statistics subgraph URL
+   */
+  hmtSubgraphUrl?: string;
+  /**
+   * HMT statistics subgraph URL API key
+   */
+  hmtSubgraphUrlApiKey?: string;
   /**
    * Old subgraph URL
    */

package/src/utils.ts

@@ -13,6 +13,8 @@ import {
   NonceExpired,
   NumericFault,
   ReplacementUnderpriced,
+  SubgraphBadIndexerError,
+  SubgraphRequestError,
   TransactionReplaced,
   WarnSubgraphApiKeyNotProvided,
 } from './error';
@@ -78,6 +80,24 @@ export const isValidJson = (input: string): boolean => {
   }
 };
 
+/**
+ * Extracts a readable message from unknown error values.
+ *
+ * @param error - Unknown error value
+ * @returns Human-readable error message
+ */
+export const getErrorMessage = (error: unknown): string => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+};
+
 /**
  * Gets the subgraph URL for the given network, using API key if available.
  *
@@ -96,6 +116,26 @@ export const getSubgraphUrl = (networkData: NetworkData) => {
   return subgraphUrl;
 };
 
+/**
+ * Gets the HMT statistics subgraph URL for the given network.
+ * Falls back to the default subgraph URL when a dedicated HMT endpoint is not configured.
+ *
+ * @param networkData - The network data containing subgraph URLs
+ * @returns The HMT statistics subgraph URL with API key if available
+ */
+export const getHMTSubgraphUrl = (networkData: NetworkData) => {
+  let subgraphUrl = networkData.hmtSubgraphUrl || networkData.subgraphUrl;
+  if (process.env.SUBGRAPH_API_KEY) {
+    subgraphUrl =
+      networkData.hmtSubgraphUrlApiKey || networkData.subgraphUrlApiKey;
+  } else if (networkData.chainId !== ChainId.LOCALHOST) {
+    // eslint-disable-next-line no-console
+    console.warn(WarnSubgraphApiKeyNotProvided);
+  }
+
+  return subgraphUrl;
+};
+
 /**
  * Converts a Date object to Unix timestamp (seconds since epoch).
  *
@@ -117,6 +157,38 @@ export const isIndexerError = (error: any): boolean => {
   return errorMessage.toLowerCase().includes('bad indexers');
 };
 
+const getSubgraphErrorMessage = (error: any): string => {
+  return (
+    error?.response?.errors?.[0]?.message ||
+    error?.message ||
+    error?.toString?.() ||
+    'Subgraph request failed'
+  );
+};
+
+const getSubgraphStatusCode = (error: any): number | undefined => {
+  if (typeof error?.response?.status === 'number') {
+    return error.response.status;
+  }
+
+  if (typeof error?.status === 'number') {
+    return error.status;
+  }
+
+  return undefined;
+};
+
+const toSubgraphError = (error: any, url: string): Error => {
+  const message = getSubgraphErrorMessage(error);
+  const statusCode = getSubgraphStatusCode(error);
+
+  if (isIndexerError(error)) {
+    return new SubgraphBadIndexerError(message, url, statusCode);
+  }
+
+  return new SubgraphRequestError(message, url, statusCode);
+};
+
 const sleep = (ms: number): Promise<void> => {
   return new Promise((resolve) => setTimeout(resolve, ms));
 };
@@ -154,7 +226,11 @@ export const customGqlFetch = async <T = any>(
     : undefined;
 
   if (!options) {
-    return await gqlFetch<T>(url, query, variables, headers);
+    try {
+      return await gqlFetch<T>(url, query, variables, headers);
+    } catch (error) {
+      throw toSubgraphError(error, url);
+    }
   }
 
   const hasMaxRetries = options.maxRetries !== undefined;
@@ -177,10 +253,11 @@ export const customGqlFetch = async <T = any>(
     try {
       return await gqlFetch<T>(targetUrl, query, variables, headers);
     } catch (error) {
-      lastError = error;
+      const wrappedError = toSubgraphError(error, targetUrl);
+      lastError = wrappedError;
 
       if (attempt === maxRetries || !isIndexerError(error)) {
-        throw error;
+        throw wrappedError;
       }
 
       const delay = baseDelay * attempt;

package/src/worker/index.ts

@@ -0,0 +1 @@
+export { WorkerUtils } from './worker_utils';

package/src/{worker.ts → worker/worker_utils.ts}

@@ -1,11 +1,11 @@
 import { ethers } from 'ethers';
-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, SubgraphOptions } from './interfaces';
-import { getSubgraphUrl, customGqlFetch } from './utils';
+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, SubgraphOptions } from '../interfaces';
+import { getSubgraphUrl, customGqlFetch } from '../utils';
 
 /**
  * Utility class for worker-related operations.