@lido-nestjs/execution 1.2.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/error/no-new-blocks-while-polling.error.d.ts

@@ -0,0 +1,6 @@
+export declare class NoNewBlocksWhilePollingError extends Error {
+    name: string;
+    message: string;
+    latestObservedBlockNumber: number;
+    constructor(message: string, latestObservedBlockNumber: number);
+}

package/dist/error/no-new-blocks-while-polling.error.js

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

package/dist/interfaces/fallback-provider.d.ts

@@ -4,4 +4,5 @@ export interface FallbackProvider {
     provider: ExtendedJsonRpcBatchProvider;
     network: Network | null;
     index: number;
+    unreachable: boolean;
 }

package/dist/interfaces/simple-fallback-provider-config.d.ts

@@ -11,5 +11,7 @@ export interface SimpleFallbackProviderConfig {
     minBackoffMs?: number;
     maxBackoffMs?: number;
     logRetries?: boolean;
+    resetIntervalMs?: number;
     fetchMiddlewares?: MiddlewareCallback<Promise<any>>[];
+    maxTimeWithoutNewBlocksMs?: number;
 }

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';
@@ -7,6 +8,7 @@ import { BlockTag } from '../ethers/block-tag';
 import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
 import { Deferrable } from '@ethersproject/properties';
 import { TransactionRequest } from '@ethersproject/abstract-provider/src.ts/index';
+import { EventType, Listener } from '@ethersproject/abstract-provider';
 /**
  * EIP-1898 support
  * https://eips.ethereum.org/EIPS/eip-1898
@@ -19,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;
@@ -26,14 +31,19 @@ export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
     protected fallbackProviders: [FallbackProvider];
     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>;
     detectNetwork(): Promise<Network>;
+    protected resetFallbacks(): void;
     protected networksEqual(networkA: Network, networkB: Network): boolean;
 }

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

@@ -9,12 +9,17 @@ var common = require('@nestjs/common');
 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.config = Object.assign({ maxRetries: 3, minBackoffMs: 500, maxBackoffMs: 5000, logRetries: true }, config);
+        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) => {
             if (!url) {
@@ -35,6 +40,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                 network: null,
                 provider,
                 index,
+                unreachable: false,
             };
         });
         this.activeFallbackProviderIndex = 0;
@@ -45,6 +51,25 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         }
         return this._formatter;
     }
+    on(eventName, listener) {
+        let dieTimer = null;
+        const startDieTimer = (latestObservedBlockNumber) => {
+            if (dieTimer)
+                clearTimeout(dieTimer);
+            dieTimer = setTimeout(async () => {
+                const error = new noNewBlocksWhilePolling_error.NoNewBlocksWhilePollingError('No new blocks for a long time while polling', latestObservedBlockNumber);
+                this.emit('error', error);
+            }, this.config.maxTimeWithoutNewBlocksMs);
+        };
+        if (eventName === 'block') {
+            startDieTimer(-1);
+            super.on(eventName, function (...args) {
+                startDieTimer(args[0]);
+                return listener.apply(this, args);
+            });
+        }
+        return super.on(eventName, listener);
+    }
     get provider() {
         if (this.activeFallbackProviderIndex > this.fallbackProviders.length - 1) {
             this.activeFallbackProviderIndex = 0;
@@ -53,7 +78,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         let attempt = 0;
         const isValid = (provider) => provider.network !== null &&
             provider.network.chainId === networks.getNetworkChain(this.config.network);
-        while (!isValid(fallbackProvider) ||
+        while (!isValid(fallbackProvider) &&
             attempt < this.fallbackProviders.length) {
             fallbackProvider =
                 this.fallbackProviders[this.activeFallbackProviderIndex];
@@ -74,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++;
@@ -88,21 +117,39 @@ 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.map((c) => c.provider.getNetwork()));
-        results.forEach((result, i) => {
+        const results = await Promise.allSettled(this.fallbackProviders
+            .filter((c) => !c.unreachable)
+            .map((c) => c.provider.getNetwork()));
+        results.forEach((result, index) => {
             if (result.status === 'fulfilled') {
-                this.fallbackProviders[i].network = result.value;
+                this.fallbackProviders[index].network = result.value;
+                this.fallbackProviders[index].unreachable = false;
             }
             else {
-                this.fallbackProviders[i].network = null;
+                this.fallbackProviders[index].network = null;
+                this.fallbackProviders[index].unreachable = true;
             }
         });
         let previousNetwork = null;
@@ -139,8 +186,26 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         if (this.detectNetworkFirstRun) {
             this.detectNetworkFirstRun = false;
         }
+        if (this.resetTimer) {
+            clearTimeout(this.resetTimer);
+        }
+        this.resetTimer = setTimeout(() => {
+            this.resetFallbacks();
+        }, this.config.resetIntervalMs || 10000);
         return previousNetwork;
     }
+    resetFallbacks() {
+        if (this.resetTimer) {
+            clearTimeout(this.resetTimer);
+        }
+        this.fallbackProviders.forEach((fallbackProvider, index) => {
+            var _a;
+            if (!((_a = this.fallbackProviders[index].network) === null || _a === void 0 ? void 0 : _a.chainId)) {
+                this.fallbackProviders[index].unreachable = false;
+            }
+        });
+        this.activeFallbackProviderIndex = 0;
+    }
     networksEqual(networkA, networkB) {
         return networks.networksEqual(networkA, networkB);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lido-nestjs/execution",
-  "version": "1.2.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",