@lido-nestjs/execution 1.4.0 → 1.7.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/ethers/fee-history.d.ts

@@ -0,0 +1,12 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { ExtendedJsonRpcBatchProvider } from '../provider/extended-json-rpc-batch-provider';
+import { SimpleFallbackJsonRpcBatchProvider } from '../provider/simple-fallback-json-rpc-batch-provider';
+export declare const MIN_BLOCKCOUNT = 1;
+export declare const MAX_BLOCKCOUNT = 1024;
+export interface FeeHistory {
+    oldestBlock: number;
+    baseFeePerGas: BigNumber[];
+    gasUsedRatio: number[];
+    reward: BigNumber[][];
+}
+export declare function getFeeHistory(this: ExtendedJsonRpcBatchProvider | SimpleFallbackJsonRpcBatchProvider, blockCount: number, newestBlock?: string | null | number, rewardPercentiles?: number[]): Promise<FeeHistory>;

package/dist/ethers/fee-history.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var bignumber = require('@ethersproject/bignumber');
+var bytes = require('@ethersproject/bytes');
+var formatBlockNumber = require('./format-block-number.js');
+var logger$1 = require('@ethersproject/logger');
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const logger = new logger$1.Logger('packages/execution');
+const MIN_BLOCKCOUNT = 1;
+const MAX_BLOCKCOUNT = 1024;
+async function getFeeHistory(blockCount, newestBlock, rewardPercentiles) {
+    var _a;
+    await this.getNetwork();
+    if (blockCount < MIN_BLOCKCOUNT || blockCount > MAX_BLOCKCOUNT) {
+        logger.throwArgumentError('Invalid blockCount for `getFeeHistory`. Should be between 1 and 1024.', 'blockCount', blockCount);
+    }
+    const params = {
+        blockCount: bytes.hexValue(blockCount),
+        newestBlock: formatBlockNumber.formatBlockNumber(newestBlock),
+        rewardPercentiles,
+    };
+    const result = await this.perform('getFeeHistory', params);
+    return {
+        baseFeePerGas: result.baseFeePerGas.map((x) => bignumber.BigNumber.from(x)),
+        gasUsedRatio: result.gasUsedRatio,
+        oldestBlock: bignumber.BigNumber.from(result.oldestBlock).toNumber(),
+        reward: ((_a = result.reward) !== null && _a !== void 0 ? _a : []).map((x) => x.map((y) => bignumber.BigNumber.from(y))),
+    };
+}
+
+exports.MAX_BLOCKCOUNT = MAX_BLOCKCOUNT;
+exports.MIN_BLOCKCOUNT = MIN_BLOCKCOUNT;
+exports.getFeeHistory = getFeeHistory;

package/dist/ethers/format-block-number.d.ts

@@ -0,0 +1 @@
+export declare const formatBlockNumber: (blockNumber: string | null | number | undefined) => string;

package/dist/ethers/format-block-number.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var bytes = require('@ethersproject/bytes');
+
+const formatBlockNumber = (blockNumber) => {
+    if (blockNumber === 'latest' ||
+        blockNumber === 'earliest' ||
+        blockNumber === 'pending') {
+        return blockNumber;
+    }
+    else if (blockNumber !== null &&
+        typeof blockNumber !== 'undefined' &&
+        (typeof blockNumber === 'number' || bytes.isHexString(blockNumber))) {
+        return bytes.hexValue(blockNumber);
+    }
+    return 'latest';
+};
+
+exports.formatBlockNumber = formatBlockNumber;

package/dist/index.d.ts

@@ -6,3 +6,4 @@ export * from './batch-provider.module';
 export * from './interfaces/fallback-provider';
 export * from './interfaces/simple-fallback-provider-config';
 export * from './interfaces/module.options';
+export * from './ethers/fee-history';

package/dist/index.js

@@ -7,6 +7,7 @@ var simpleFallbackJsonRpcBatchProvider = require('./provider/simple-fallback-jso
 var queue = require('./common/queue.js');
 var fallbackProvider_module = require('./fallback-provider.module.js');
 var batchProvider_module = require('./batch-provider.module.js');
+var feeHistory = require('./ethers/fee-history.js');
 
 
 
@@ -27,3 +28,6 @@ Object.defineProperty(exports, 'BatchProviderModule', {
 	enumerable: true,
 	get: function () { return batchProvider_module.BatchProviderModule; }
 });
+exports.MAX_BLOCKCOUNT = feeHistory.MAX_BLOCKCOUNT;
+exports.MIN_BLOCKCOUNT = feeHistory.MIN_BLOCKCOUNT;
+exports.getFeeHistory = feeHistory.getFeeHistory;

package/dist/provider/extended-json-rpc-batch-provider.d.ts

@@ -9,6 +9,7 @@ import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
 import { BlockTag } from '../ethers/block-tag';
 import { TransactionRequest } from '@ethersproject/abstract-provider/src.ts/index';
 import { MiddlewareCallback, MiddlewareService } from '@lido-nestjs/middleware';
+import { FeeHistory } from '../ethers/fee-history';
 export interface RequestPolicy {
     jsonRpcMaxBatchSize: number;
     maxConcurrentRequests: number;
@@ -70,6 +71,8 @@ export declare class ExtendedJsonRpcBatchProvider extends JsonRpcProvider {
     static getFormatter(): Formatter;
     protected _batchAggregatorTick(): void;
     protected _startBatchAggregator(): void;
+    getFeeHistory(blockCount: number, newestBlock?: string | null | number, rewardPercentiles?: number[]): Promise<FeeHistory>;
+    prepareRequest(method: string, params: any): [string, Array<any>];
     use(callback: MiddlewareCallback<Promise<any>>): void;
     send(method: string, params: Array<unknown>): Promise<unknown>;
     detectNetwork(): Promise<Network>;

package/dist/provider/extended-json-rpc-batch-provider.js

@@ -12,6 +12,7 @@ var common = require('@nestjs/common');
 var promiseLimit = require('../common/promise-limit.js');
 var formatterWithEip1898 = require('../ethers/formatter-with-eip1898.js');
 var middleware = require('@lido-nestjs/middleware');
+var feeHistory = require('../ethers/fee-history.js');
 
 exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extends providers.JsonRpcProvider {
     constructor(url, network, requestPolicy, fetchMiddlewares = []) {
@@ -102,6 +103,20 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
             this._batchAggregator = setTimeout(this._batchAggregatorTick.bind(this), this._requestPolicy.batchAggregationWaitMs);
         }
     }
+    async getFeeHistory(blockCount, newestBlock, rewardPercentiles) {
+        return feeHistory.getFeeHistory.call(this, blockCount, newestBlock, rewardPercentiles);
+    }
+    prepareRequest(method, params) {
+        switch (method) {
+            case 'getFeeHistory':
+                return [
+                    'eth_feeHistory',
+                    [params.blockCount, params.newestBlock, params.rewardPercentiles],
+                ];
+            default:
+                return super.prepareRequest(method, params);
+        }
+    }
     use(callback) {
         this._fetchMiddlewareService.use(callback);
     }

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';
@@ -8,6 +9,7 @@ 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';
+import { FeeHistory } from '../ethers/fee-history';
 /**
  * EIP-1898 support
  * https://eips.ethereum.org/EIPS/eip-1898
@@ -20,6 +22,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 +33,15 @@ 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;
+    getFeeHistory(blockCount: number, newestBlock?: string | null | number, rewardPercentiles?: number[]): Promise<FeeHistory>;
     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,16 @@ 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');
+var feeHistory = require('../ethers/fee-history.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) => {
@@ -67,6 +71,9 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         }
         return super.on(eventName, listener);
     }
+    async getFeeHistory(blockCount, newestBlock, rewardPercentiles) {
+        return feeHistory.getFeeHistory.call(this, blockCount, newestBlock, rewardPercentiles);
+    }
     get provider() {
         if (this.activeFallbackProviderIndex > this.fallbackProviders.length - 1) {
             this.activeFallbackProviderIndex = 0;
@@ -96,12 +103,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 +121,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.7.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
@@ -34,6 +34,9 @@
     "access": "public"
   },
   "dependencies": {
+    "@ethersproject/bignumber": "^5.5.0",
+    "@ethersproject/bytes": "^5.5.0",
+    "@ethersproject/logger": "^5.5.0",
     "@ethersproject/networks": "^5.5.2",
     "@ethersproject/properties": "^5.5.0",
     "@ethersproject/providers": "^5.5.3",