@lido-nestjs/execution 1.4.0 → 1.5.0

package/dist/common/errors.d.ts

@@ -0,0 +1,5 @@
+export declare const nonRetryableErrors: (string | number)[];
+export declare type ErrorWithCode = Error & {
+    code: number | string;
+};
+export declare const isErrorHasCode: (error: unknown) => error is ErrorWithCode;

package/dist/common/errors.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger = require('@ethersproject/logger');
+
+const nonRetryableErrors = [
+    ///////////////////
+    // Generic Errors
+    // Not Implemented
+    logger.ErrorCode.NOT_IMPLEMENTED,
+    // Timeout
+    logger.ErrorCode.TIMEOUT,
+    ///////////////////
+    // Operational  Errors
+    // Buffer Overrun
+    logger.ErrorCode.BUFFER_OVERRUN,
+    // Numeric Fault
+    //   - operation: the operation being executed
+    //   - fault: the reason this faulted
+    logger.ErrorCode.NUMERIC_FAULT,
+    ///////////////////
+    // Argument Errors
+    // Missing new operator to an object
+    //  - name: The name of the class
+    logger.ErrorCode.MISSING_NEW,
+    // Invalid argument (e.g. value is incompatible with type) to a function:
+    //   - argument: The argument name that was invalid
+    //   - value: The value of the argument
+    logger.ErrorCode.INVALID_ARGUMENT,
+    // Missing argument to a function:
+    //   - count: The number of arguments received
+    //   - expectedCount: The number of arguments expected
+    logger.ErrorCode.MISSING_ARGUMENT,
+    // Too many arguments
+    //   - count: The number of arguments received
+    //   - expectedCount: The number of arguments expected
+    logger.ErrorCode.UNEXPECTED_ARGUMENT,
+    ///////////////////
+    // Blockchain Errors
+    // Call exception
+    //  - transaction: the transaction
+    //  - address?: the contract address
+    //  - args?: The arguments passed into the function
+    //  - method?: The Solidity method signature
+    //  - errorSignature?: The EIP848 error signature
+    //  - errorArgs?: The EIP848 error parameters
+    //  - reason: The reason (only for EIP848 "Error(string)")
+    logger.ErrorCode.CALL_EXCEPTION,
+    // Insufficient funds (< value + gasLimit * gasPrice)
+    //   - transaction: the transaction attempted
+    logger.ErrorCode.INSUFFICIENT_FUNDS,
+    // Nonce has already been used
+    //   - transaction: the transaction attempted
+    logger.ErrorCode.NONCE_EXPIRED,
+    // The replacement fee for the transaction is too low
+    //   - transaction: the transaction attempted
+    logger.ErrorCode.REPLACEMENT_UNDERPRICED,
+    // The gas limit could not be estimated
+    //   - transaction: the transaction passed to estimateGas
+    logger.ErrorCode.UNPREDICTABLE_GAS_LIMIT,
+    // The transaction was replaced by one with a higher gas price
+    //   - reason: "cancelled", "replaced" or "repriced"
+    //   - cancelled: true if reason == "cancelled" or reason == "replaced")
+    //   - hash: original transaction hash
+    //   - replacement: the full TransactionsResponse for the replacement
+    //   - receipt: the receipt of the replacement
+    logger.ErrorCode.TRANSACTION_REPLACED,
+];
+const isErrorHasCode = (error) => {
+    return (error instanceof Error &&
+        Object.prototype.hasOwnProperty.call(error, 'code'));
+};
+
+exports.isErrorHasCode = isErrorHasCode;
+exports.nonRetryableErrors = nonRetryableErrors;

package/dist/common/retrier.d.ts

@@ -1,2 +1,2 @@
 import { LoggerService } from '@nestjs/common/services/logger.service';
-export declare const retrier: (logger?: LoggerService | null | undefined, defaultMaxRetryCount?: number, defaultMinBackoffMs?: number, defaultMaxBackoffMs?: number, defaultLogWarning?: boolean) => <T extends unknown>(callback: () => T | Promise<T>, maxRetryCount?: number | undefined, minBackoffMs?: number | undefined, maxBackoffMs?: number | undefined, logWarning?: boolean | undefined) => Promise<T>;
+export declare const retrier: (logger?: LoggerService | null | undefined, defaultMaxRetryCount?: number, defaultMinBackoffMs?: number, defaultMaxBackoffMs?: number, defaultLogWarning?: boolean, defaultErrorFilter?: ((error: Error | unknown) => boolean) | undefined) => <T extends unknown>(callback: () => T | Promise<T>, maxRetryCount?: number | undefined, minBackoffMs?: number | undefined, maxBackoffMs?: number | undefined, logWarning?: boolean | undefined, errorFilter?: ((error: Error | unknown) => boolean) | undefined) => Promise<T>;

package/dist/common/retrier.js

@@ -4,16 +4,20 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var sleep = require('./sleep.js');
 
-const retrier = (logger, defaultMaxRetryCount = 3, defaultMinBackoffMs = 1000, defaultMaxBackoffMs = 60000, defaultLogWarning = false) => {
-    return async (callback, maxRetryCount, minBackoffMs, maxBackoffMs, logWarning) => {
+const retrier = (logger, defaultMaxRetryCount = 3, defaultMinBackoffMs = 1000, defaultMaxBackoffMs = 60000, defaultLogWarning = false, defaultErrorFilter) => {
+    return async (callback, maxRetryCount, minBackoffMs, maxBackoffMs, logWarning, errorFilter) => {
         maxRetryCount = maxRetryCount !== null && maxRetryCount !== void 0 ? maxRetryCount : defaultMaxRetryCount;
         minBackoffMs = minBackoffMs !== null && minBackoffMs !== void 0 ? minBackoffMs : defaultMinBackoffMs;
         maxBackoffMs = maxBackoffMs !== null && maxBackoffMs !== void 0 ? maxBackoffMs : defaultMaxBackoffMs;
         logWarning = logWarning !== null && logWarning !== void 0 ? logWarning : defaultLogWarning;
+        errorFilter = errorFilter !== null && errorFilter !== void 0 ? errorFilter : defaultErrorFilter;
         try {
             return await callback();
         }
         catch (err) {
+            if (typeof errorFilter === 'function' && errorFilter(err)) {
+                throw err;
+            }
             if (logger && logWarning) {
                 logger.warn(err, 'Retrying after (%dms). Remaining retries [%d]', minBackoffMs, maxRetryCount);
             }
@@ -21,7 +25,7 @@ const retrier = (logger, defaultMaxRetryCount = 3, defaultMinBackoffMs = 1000, d
                 throw err;
             }
             await sleep.sleep(minBackoffMs);
-            return await retrier(logger)(callback, maxRetryCount - 1, minBackoffMs * 2, maxBackoffMs, logWarning);
+            return await retrier(logger)(callback, maxRetryCount - 1, minBackoffMs * 2, maxBackoffMs, logWarning, errorFilter);
         }
     };
 };

package/dist/error/all-providers-failed.error.d.ts

@@ -0,0 +1,7 @@
+export declare class AllProvidersFailedError extends Error {
+    name: string;
+    message: string;
+    code: number;
+    originalError: Error | unknown;
+    constructor(message: string);
+}

package/dist/error/all-providers-failed.error.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class AllProvidersFailedError extends Error {
+    constructor(message) {
+        super('');
+        this.name = 'AllProvidersFailedError';
+        this.code = 0;
+        this.message = message;
+    }
+}
+
+exports.AllProvidersFailedError = AllProvidersFailedError;

package/dist/provider/simple-fallback-json-rpc-batch-provider.d.ts

@@ -1,4 +1,5 @@
 import { BaseProvider, Formatter } from '@ethersproject/providers';
+import { CallOverrides as CallOverridesSource } from '@ethersproject/contracts';
 import { SimpleFallbackProviderConfig } from '../interfaces/simple-fallback-provider-config';
 import { Network } from '@ethersproject/networks';
 import { LoggerService } from '@nestjs/common';
@@ -20,6 +21,9 @@ declare module '@ethersproject/providers' {
         getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
         call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
     }
+    interface CallOverrides extends Omit<CallOverridesSource, 'blockTag'> {
+        blockTag?: BlockTag;
+    }
 }
 export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
     protected config: SimpleFallbackProviderConfig;
@@ -28,12 +32,14 @@ export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
     protected activeFallbackProviderIndex: number;
     protected detectNetworkFirstRun: boolean;
     protected resetTimer: ReturnType<typeof setTimeout> | null;
+    protected lastPerformError: Error | null | unknown;
     constructor(config: SimpleFallbackProviderConfig, logger: LoggerService);
     static _formatter: Formatter | null;
     static getFormatter(): Formatter;
     on(eventName: EventType, listener: Listener): this;
     protected get provider(): FallbackProvider;
     protected switchToNextProvider(): void;
+    protected errorShouldBeReThrown(error: Error | unknown): boolean;
     perform(method: string, params: {
         [name: string]: unknown;
     }): Promise<unknown>;

package/dist/provider/simple-fallback-json-rpc-batch-provider.js

@@ -10,12 +10,15 @@ var retrier = require('../common/retrier.js');
 var formatterWithEip1898 = require('../ethers/formatter-with-eip1898.js');
 var networks = require('../common/networks.js');
 var noNewBlocksWhilePolling_error = require('../error/no-new-blocks-while-polling.error.js');
+var errors = require('../common/errors.js');
+var allProvidersFailed_error = require('../error/all-providers-failed.error.js');
 
 exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchProvider extends providers.BaseProvider {
     constructor(config, logger) {
         super(config.network);
         this.detectNetworkFirstRun = true;
         this.resetTimer = null;
+        this.lastPerformError = null;
         this.config = Object.assign({ maxRetries: 3, minBackoffMs: 500, maxBackoffMs: 5000, logRetries: true, resetIntervalMs: 10000, maxTimeWithoutNewBlocksMs: 60000 }, config);
         this.logger = logger;
         const conns = config.urls.filter((url) => {
@@ -96,12 +99,16 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         this.activeFallbackProviderIndex++;
         this.logger.log(`Switched to next provider for execution layer`);
     }
+    errorShouldBeReThrown(error) {
+        return errors.isErrorHasCode(error) && errors.nonRetryableErrors.includes(error.code);
+    }
     async perform(method, params) {
-        const retry = retrier.retrier(this.logger, this.config.maxRetries, this.config.minBackoffMs, this.config.maxBackoffMs, this.config.logRetries);
+        const retry = retrier.retrier(this.logger, this.config.maxRetries, this.config.minBackoffMs, this.config.maxBackoffMs, this.config.logRetries, (e) => this.errorShouldBeReThrown(e));
         let attempt = 0;
         // will perform maximum `this.config.maxRetries` retries for fetching data with single provider
         // after failure will switch to next provider
         // maximum number of switching is limited to total fallback provider count
+        let lastError;
         while (attempt < this.fallbackProviders.length) {
             try {
                 attempt++;
@@ -110,12 +117,26 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                 return await retry(() => this.provider.provider.perform(method, params));
             }
             catch (e) {
+                if (this.errorShouldBeReThrown(e)) {
+                    throw e;
+                }
                 this.logger.error('Error while doing ETH1 RPC request. Will try to switch to another provider');
+                lastError = e;
                 this.logger.error(e);
-                this.switchToNextProvider();
+                // This check is needed to avoid multiple `switchToNextProvider` calls when doing one JSON-RPC batch.
+                // This can happen when multiple N calls to `perform` are batched in one JSON-RPC request and
+                // that request fails and throws `Error`. This `Error` is bubbled N times to corresponding `perform` calls.
+                // Without the following check, each `perform` call from batch catches `Error` and switches to the next provider,
+                // so during one batch multiple switching to next provider can occur, which is not needed.
+                if (this.lastPerformError != e) {
+                    this.switchToNextProvider();
+                    this.lastPerformError = e;
+                }
             }
         }
-        throw new Error('All attempts to do ETH1 RPC request failed');
+        const allProvidersFailedError = new allProvidersFailed_error.AllProvidersFailedError('All attempts to do ETH1 RPC request failed');
+        allProvidersFailedError.originalError = lastError;
+        throw allProvidersFailedError;
     }
     async detectNetwork() {
         const results = await Promise.allSettled(this.fallbackProviders

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lido-nestjs/execution",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
@@ -34,6 +34,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@ethersproject/logger": "^5.5.0",
     "@ethersproject/networks": "^5.5.2",
     "@ethersproject/properties": "^5.5.0",
     "@ethersproject/providers": "^5.5.3",