feat: error classification

packages/chain-providers/src/exceptions/dataDecode.exception.ts

@@ -1,6 +1,7 @@
-export class DataDecodeException extends Error {
+import { NonRetriableError } from "@grants-stack-indexer/shared";
+
+export class DataDecodeException extends NonRetriableError {
     constructor(message: string) {
         super(message);
-        this.name = "DataDecodeException";
     }
 }

packages/chain-providers/src/exceptions/invalidArgument.exception.ts

@@ -1,6 +1,7 @@
-export class InvalidArgumentException extends Error {
+import { NonRetriableError } from "@grants-stack-indexer/shared";
+
+export class InvalidArgumentException extends NonRetriableError {
     constructor(message: string) {
         super(message);
-        this.name = "InvalidArgumentException";
     }
 }

packages/chain-providers/src/exceptions/multicallNotFound.exception.ts

@@ -1,4 +1,6 @@
-export class MulticallNotFound extends Error {
+import { NonRetriableError } from "@grants-stack-indexer/shared";
+
+export class MulticallNotFound extends NonRetriableError {
     constructor() {
         super("Multicall contract address not found");
     }

packages/chain-providers/src/exceptions/rpcUrlsEmpty.exception.ts

@@ -1,6 +1,7 @@
-export class RpcUrlsEmpty extends Error {
+import { NonRetriableError } from "@grants-stack-indexer/shared";
+
+export class RpcUrlsEmpty extends NonRetriableError {
     constructor() {
         super("RPC URLs array cannot be empty");
-        this.name = "RpcUrlsEmpty";
     }
 }

packages/chain-providers/src/providers/evmProvider.ts

@@ -22,10 +22,12 @@ import {
     HttpTransport,
     MulticallParameters,
     MulticallReturnType,
+    RpcError,
+    TimeoutError,
     toHex,
 } from "viem";
 
-import { ILogger } from "@grants-stack-indexer/shared";
+import { ILogger, NonRetriableError, RetriableError } from "@grants-stack-indexer/shared";
 
 import {
     AbiWithConstructor,
@@ -67,7 +69,11 @@ export class EvmProvider {
     }
 
     async getTransaction(hash: Hex): Promise<GetTransactionReturnType> {
-        return this.client.getTransaction({ hash });
+        try {
+            return await this.client.getTransaction({ hash });
+        } catch (e) {
+            throw this.wrapError(e, "getTransaction", "Failed to get transaction", { hash });
+        }
     }
 
     /**
@@ -76,35 +82,57 @@ export class EvmProvider {
      * @returns {Promise<bigint>} A Promise that resolves to the balance of the address.
      */
     async getBalance(address: Address): Promise<bigint> {
-        return this.client.getBalance({ address });
+        try {
+            return await this.client.getBalance({ address });
+        } catch (e) {
+            throw this.wrapError(e, "getBalance", "Failed to get balance", { address });
+        }
     }
 
     /**
      * Retrieves the current block number.
      * @returns {Promise<bigint>} A Promise that resolves to the latest block number.
      */
     async getBlockNumber(): Promise<bigint> {
-        return this.client.getBlockNumber();
+        try {
+            return await this.client.getBlockNumber();
+        } catch (e) {
+            throw this.wrapError(e, "getBlockNumber", "Failed to get block number");
+        }
     }
 
     /**
      * Retrieves the current block number.
      * @returns {Promise<GetBlockReturnType>} Latest block number.
      */
     async getBlockByNumber(blockNumber: bigint): Promise<GetBlockReturnType> {
-        return this.client.getBlock({ blockNumber });
+        try {
+            return await this.client.getBlock({ blockNumber });
+        } catch (e) {
+            throw this.wrapError(e, "getBlockByNumber", "Failed to get block", {
+                blockNumber: blockNumber.toString(),
+            });
+        }
     }
 
     /**
      * Retrieves the current estimated gas price on the chain.
      * @returns {Promise<bigint>} A Promise that resolves to the current gas price.
      */
     async getGasPrice(): Promise<bigint> {
-        return this.client.getGasPrice();
+        try {
+            return await this.client.getGasPrice();
+        } catch (e) {
+            throw this.wrapError(e, "getGasPrice", "Failed to get gas price");
+        }
     }
 
     async estimateGas(args: EstimateGasParameters<typeof this.chain>): Promise<bigint> {
-        return this.client.estimateGas(args);
+        try {
+            return await this.client.estimateGas(args);
+        } catch (e) {
+            throw this.wrapError(e, "estimateGas", "Failed to estimate gas", args);
+        }
     }
 
     /**
@@ -121,10 +149,14 @@ export class EvmProvider {
             );
         }
 
-        return this.client.getStorageAt({
-            address,
-            slot: typeof slot === "string" ? slot : toHex(slot),
-        });
+        try {
+            return await this.client.getStorageAt({
+                address,
+                slot: typeof slot === "string" ? slot : toHex(slot),
+            });
+        } catch (e) {
+            throw this.wrapError(e, "getStorageAt", "Failed to get storage", { address, slot });
+        }
     }
 
     /**
@@ -137,27 +169,28 @@ export class EvmProvider {
      */
     async readContract<
         TAbi extends Abi,
-        TFunctionName extends ContractFunctionName<TAbi, "pure" | "view"> = ContractFunctionName<
-            TAbi,
-            "pure" | "view"
-        >,
-        TArgs extends ContractFunctionArgs<
-            TAbi,
-            "pure" | "view",
-            TFunctionName
-        > = ContractFunctionArgs<TAbi, "pure" | "view", TFunctionName>,
+        TFunctionName extends ContractFunctionName<TAbi, "pure" | "view">,
+        TArgs extends ContractFunctionArgs<TAbi, "pure" | "view", TFunctionName>,
     >(
         contractAddress: Address,
         abi: TAbi,
         functionName: TFunctionName,
         args?: TArgs,
     ): Promise<ContractFunctionReturnType<TAbi, "pure" | "view", TFunctionName, TArgs>> {
-        return this.client.readContract({
-            address: contractAddress,
-            abi,
-            functionName,
-            args,
-        });
+        try {
+            return await this.client.readContract({
+                address: contractAddress,
+                abi,
+                functionName,
+                args,
+            });
+        } catch (e) {
+            throw this.wrapError(e, "readContract", "Failed to read contract", {
+                contractAddress,
+                functionName,
+                args,
+            });
+        }
     }
 
     /**
@@ -177,19 +210,27 @@ export class EvmProvider {
     ): Promise<DecodeAbiParametersReturnType<ReturnType>> {
         const deploymentData = args ? encodeDeployData({ abi, bytecode, args }) : bytecode;
 
-        const { data: returnData } = await this.client.call({
-            data: deploymentData,
-        });
+        try {
+            const { data: returnData } = await this.client.call({
+                data: deploymentData,
+            });
 
-        if (!returnData) {
-            throw new DataDecodeException("No return data");
-        }
+            if (!returnData) {
+                throw new DataDecodeException("No return data");
+            }
 
-        try {
-            const decoded = decodeAbiParameters(constructorReturnParams, returnData);
-            return decoded;
+            try {
+                return decodeAbiParameters(constructorReturnParams, returnData);
+            } catch (e) {
+                throw new DataDecodeException(
+                    "Error decoding return data with given AbiParameters",
+                );
+            }
         } catch (e) {
-            throw new DataDecodeException("Error decoding return data with given AbiParameters");
+            if (e instanceof DataDecodeException) {
+                throw e;
+            }
+            throw this.wrapError(e, "batchRequest", "Failed to execute batch request", { args });
         }
     }
 
@@ -208,6 +249,40 @@ export class EvmProvider {
     ): Promise<MulticallReturnType<contracts, allowFailure>> {
         if (!this.chain?.contracts?.multicall3?.address) throw new MulticallNotFound();
 
-        return this.client.multicall<contracts, allowFailure>(args);
+        try {
+            return await this.client.multicall<contracts, allowFailure>(args);
+        } catch (e) {
+            throw this.wrapError(e, "multicall", "Failed to execute multicall", { args });
+        }
+    }
+
+    private wrapError(
+        error: unknown,
+        methodName: Exclude<
+            keyof typeof EvmProvider.prototype,
+            "constructor" | "wrapError" | "logger" | "chain" | "client"
+        >,
+        errorMessage: string,
+        additionalData?: Record<string, unknown>,
+    ): RetriableError | NonRetriableError {
+        const err = error as Error;
+        if (err instanceof TimeoutError || err instanceof RpcError) {
+            return new RetriableError(errorMessage, {
+                className: EvmProvider.name,
+                methodName,
+                chainId: this.chain?.id?.toString(),
+                additionalData,
+            });
+        }
+        return new NonRetriableError(
+            err.message,
+            {
+                className: "EvmProvider",
+                methodName,
+                chainId: this.chain?.id?.toString(),
+                additionalData,
+            },
+            err,
+        );
     }
 }

packages/data-flow/src/exceptions/invalidChangeset.exception.ts

@@ -1,4 +1,6 @@
-export class InvalidChangeset extends Error {
+import { NonRetriableError } from "@grants-stack-indexer/shared";
+
+export class InvalidChangeset extends NonRetriableError {
     constructor(invalidTypes: string[]) {
         super(`Invalid changeset types: ${invalidTypes.join(", ")}`);
     }

packages/data-flow/src/exceptions/invalidEvent.ts

@@ -1,6 +1,12 @@
-import { AnyEvent, ContractName, ProcessorEvent, stringify } from "@grants-stack-indexer/shared";
+import {
+    AnyEvent,
+    ContractName,
+    NonRetriableError,
+    ProcessorEvent,
+    stringify,
+} from "@grants-stack-indexer/shared";
 
-export class InvalidEvent extends Error {
+export class InvalidEvent extends NonRetriableError {
     constructor(event: ProcessorEvent<ContractName, AnyEvent>) {
         super(`Event couldn't be processed: ${stringify(event)}`);
 

packages/indexer-client/src/exceptions/indexerClientError.exception.ts

@@ -1,6 +1,7 @@
-export class IndexerClientError extends Error {
-    constructor(message: string) {
-        super(`Indexer client error - ${message}`);
-        this.name = "IndexerClientError";
+import { ErrorContext, NonRetriableError } from "@grants-stack-indexer/shared";
+
+export class IndexerClientError extends NonRetriableError {
+    constructor(message: string, context?: ErrorContext, error?: Error) {
+        super(`Indexer client error - ${message}`, context, error);
     }
 }

packages/indexer-client/src/exceptions/invalidIndexerResponse.exception.ts

@@ -1,6 +1,7 @@
-export class InvalidIndexerResponse extends Error {
+import { NonRetriableError } from "@grants-stack-indexer/shared";
+
+export class InvalidIndexerResponse extends NonRetriableError {
     constructor(response: string) {
         super(`Indexer response is invalid - ${response}`);
-        this.name = "InvalidIndexerResponse";
     }
 }

packages/indexer-client/src/providers/envioIndexerClient.ts

@@ -70,7 +70,14 @@ export class EnvioIndexerClient implements IIndexerClient {
             if (error instanceof InvalidIndexerResponse) {
                 throw error;
             }
-            throw new IndexerClientError(stringify(error, Object.getOwnPropertyNames(error)));
+            throw new IndexerClientError(
+                stringify(error, Object.getOwnPropertyNames(error)),
+                {
+                    className: EnvioIndexerClient.name,
+                    methodName: "getEventsAfterBlockNumberAndLogIndex",
+                },
+                error as Error,
+            );
         }
     }
 

packages/metadata/src/exceptions/emptyGateways.exception.ts

@@ -1,4 +1,6 @@
-export class EmptyGatewaysUrlsException extends Error {
+import { NonRetriableError } from "@grants-stack-indexer/shared";
+
+export class EmptyGatewaysUrlsException extends NonRetriableError {
     constructor() {
         super("Gateways array cannot be empty");
     }

packages/metadata/src/exceptions/invalidCid.exception.ts

@@ -1,6 +1,7 @@
-export class InvalidCidException extends Error {
+import { NonRetriableError } from "@grants-stack-indexer/shared";
+
+export class InvalidCidException extends NonRetriableError {
     constructor(cid: string) {
         super(`Invalid CID: ${cid}`);
-        this.name = "InvalidCidException";
     }
 }

packages/metadata/src/exceptions/invalidContent.exception.ts

@@ -1,4 +1,6 @@
-export class InvalidContentException extends Error {
+import { NonRetriableError } from "@grants-stack-indexer/shared";
+
+export class InvalidContentException extends NonRetriableError {
     constructor(message: string) {
         super(message);
     }

packages/pricing/src/exceptions/index.ts

@@ -1,4 +1,3 @@
-export * from "./network.exception.js";
 export * from "./unsupportedChain.exception.js";
 export * from "./unknownPricing.exception.js";
 export * from "./unsupportedToken.exception.js";

packages/pricing/src/exceptions/unknownPricing.exception.ts

@@ -1,6 +1,7 @@
-export class UnknownPricingException extends Error {
-    constructor(message: string, stack?: string) {
-        super(message);
-        this.stack = stack;
+import { ErrorContext, RetriableError } from "@grants-stack-indexer/shared";
+
+export class UnknownPricingException extends RetriableError {
+    constructor(message: string, context: ErrorContext) {
+        super(message, context);
     }
 }

packages/pricing/src/exceptions/unsupportedToken.exception.ts

@@ -1,7 +1,7 @@
-import { TokenCode } from "@grants-stack-indexer/shared";
+import { ErrorContext, NonRetriableError, TokenCode } from "@grants-stack-indexer/shared";
 
-export class UnsupportedToken extends Error {
-    constructor(tokenCode: TokenCode) {
-        super(`Unsupported token: ${tokenCode}`);
+export class UnsupportedToken extends NonRetriableError {
+    constructor(tokenCode: TokenCode, context: ErrorContext) {
+        super(`Unsupported token: ${tokenCode}`, context);
     }
 }