@lido-nestjs/execution 1.10.1 → 1.11.0

package/dist/common/errors.d.ts

@@ -2,8 +2,20 @@ export declare const nonRetryableErrors: (string | number)[];
 export declare type ErrorWithCode = Error & {
     code: number | string;
 };
-export declare type ServerError = ErrorWithCode & {
+export declare type HasErrorProperty = {
+    error: object;
+};
+export declare type HasServerErrorProperty = {
     serverError: object;
 };
 export declare const isErrorHasCode: (error: unknown) => error is ErrorWithCode;
-export declare const isCallExceptionServerError: (error: ErrorWithCode) => error is ServerError;
+export declare const hasErrorProperty: (error: unknown) => error is HasErrorProperty;
+export declare const hasServerErrorProperty: (error: unknown) => error is HasServerErrorProperty;
+/**
+ * Detect that ethers error is a server error.
+ *
+ * Note: Ethers v5 error management is not very clean,
+ * and ethers error can be nested.
+ *
+ */
+export declare const isEthersServerError: (error: unknown) => boolean;

package/dist/common/errors.js

@@ -69,11 +69,30 @@ const isErrorHasCode = (error) => {
     return (error instanceof Error &&
         Object.prototype.hasOwnProperty.call(error, 'code'));
 };
-const isCallExceptionServerError = (error) => {
-    return (error.code === logger.ErrorCode.CALL_EXCEPTION &&
-        Object.prototype.hasOwnProperty.call(error, 'serverError'));
+const hasErrorProperty = (error) => {
+    return Object.prototype.hasOwnProperty.call(error, 'error');
+};
+const hasServerErrorProperty = (error) => {
+    return Object.prototype.hasOwnProperty.call(error, 'serverError');
+};
+/**
+ * Detect that ethers error is a server error.
+ *
+ * Note: Ethers v5 error management is not very clean,
+ * and ethers error can be nested.
+ *
+ */
+const isEthersServerError = (error) => {
+    return (hasServerErrorProperty(error) || // nesting level 0
+        (hasErrorProperty(error) && hasServerErrorProperty(error.error)) || // nesting level 1
+        (hasErrorProperty(error) &&
+            hasErrorProperty(error.error) &&
+            hasServerErrorProperty(error.error.error)) // nesting level 2
+    );
 };
 
-exports.isCallExceptionServerError = isCallExceptionServerError;
+exports.hasErrorProperty = hasErrorProperty;
+exports.hasServerErrorProperty = hasServerErrorProperty;
 exports.isErrorHasCode = isErrorHasCode;
+exports.isEthersServerError = isEthersServerError;
 exports.nonRetryableErrors = nonRetryableErrors;

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

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

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

@@ -4,10 +4,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 class AllProvidersFailedError extends Error {
     constructor(message) {
-        super('');
+        super(message);
         this.name = 'AllProvidersFailedError';
         this.code = 0;
-        this.message = message;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+    // for backward-compatibility
+    get originalError() {
+        return this.cause;
     }
 }
 

package/dist/error/codes/error-codes.d.ts

@@ -0,0 +1,4 @@
+export declare enum ErrorCode {
+    UNEXPECTED_BATCH_RESULT = "UNEXPECTED_BATCH_RESULT",
+    PARTIAL_BATCH_RESULT = "PARTIAL_BATCH_RESULT"
+}

package/dist/error/codes/error-codes.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+exports.ErrorCode = void 0;
+(function (ErrorCode) {
+    ErrorCode["UNEXPECTED_BATCH_RESULT"] = "UNEXPECTED_BATCH_RESULT";
+    ErrorCode["PARTIAL_BATCH_RESULT"] = "PARTIAL_BATCH_RESULT";
+})(exports.ErrorCode || (exports.ErrorCode = {}));

package/dist/error/fetch.error.d.ts

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

package/dist/error/fetch.error.js

@@ -4,10 +4,10 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 class FetchError extends Error {
     constructor(message) {
-        super('');
+        super(message);
         this.name = 'FetchError';
         this.code = 0;
-        this.message = message;
+        Object.setPrototypeOf(this, new.target.prototype);
     }
 }
 

package/dist/error/index.d.ts

@@ -0,0 +1,3 @@
+export * from './all-providers-failed.error';
+export * from './fetch.error';
+export * from './no-new-blocks-while-polling.error';

package/dist/error/no-new-blocks-while-polling.error.d.ts

@@ -1,6 +1,5 @@
 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

@@ -4,9 +4,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 class NoNewBlocksWhilePollingError extends Error {
     constructor(message, latestObservedBlockNumber) {
-        super('');
+        super(message);
         this.name = 'NoNewBlocksWhilePollingError';
-        this.message = message;
+        Object.setPrototypeOf(this, new.target.prototype);
         this.latestObservedBlockNumber = latestObservedBlockNumber;
     }
 }

package/dist/index.d.ts

@@ -8,3 +8,4 @@ export * from './interfaces/simple-fallback-provider-config';
 export * from './interfaces/module.options';
 export * from './interfaces/non-empty-array';
 export * from './ethers/fee-history';
+export * from './error';

package/dist/index.js

@@ -8,6 +8,9 @@ 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');
+var allProvidersFailed_error = require('./error/all-providers-failed.error.js');
+var fetch_error = require('./error/fetch.error.js');
+var noNewBlocksWhilePolling_error = require('./error/no-new-blocks-while-polling.error.js');
 
 
 
@@ -31,3 +34,6 @@ Object.defineProperty(exports, 'BatchProviderModule', {
 exports.MAX_BLOCKCOUNT = feeHistory.MAX_BLOCKCOUNT;
 exports.MIN_BLOCKCOUNT = feeHistory.MIN_BLOCKCOUNT;
 exports.getFeeHistory = feeHistory.getFeeHistory;
+exports.AllProvidersFailedError = allProvidersFailed_error.AllProvidersFailedError;
+exports.FetchError = fetch_error.FetchError;
+exports.NoNewBlocksWhilePollingError = noNewBlocksWhilePolling_error.NoNewBlocksWhilePollingError;

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

@@ -13,6 +13,7 @@ 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');
+var errorCodes = require('../error/codes/error-codes.js');
 
 exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extends providers.JsonRpcProvider {
     constructor(url, network, requestPolicy, fetchMiddlewares = []) {
@@ -56,12 +57,24 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
                 });
             })
                 .then((batchResult) => {
+                var _a;
                 this.emit('debug', {
                     action: 'response',
                     request: properties.deepCopy(batchRequest),
                     response: properties.deepCopy(batchResult),
                     provider: this,
                 });
+                if (!Array.isArray(batchResult)) {
+                    const errMessage = 'Unexpected batch result.';
+                    const jsonRpcErrorMessage = (_a = batchResult.error) === null || _a === void 0 ? void 0 : _a.message;
+                    const detailedMessage = jsonRpcErrorMessage
+                        ? ` Possible reason: "${jsonRpcErrorMessage}".`
+                        : '';
+                    const error = new fetch_error.FetchError(errMessage + detailedMessage);
+                    error.code = errorCodes.ErrorCode.UNEXPECTED_BATCH_RESULT;
+                    error.data = batchResult.error;
+                    throw error;
+                }
                 const resultMap = batchResult.reduce((resultMap, payload) => {
                     resultMap[payload.id] = payload;
                     return resultMap;
@@ -70,7 +83,13 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
                 // on whether it was a success or error
                 batch.forEach((inflightRequest) => {
                     const payload = resultMap[inflightRequest.request.id];
-                    if (payload.error) {
+                    if (!payload) {
+                        const error = new fetch_error.FetchError(`Partial payload batch result. Response ${inflightRequest.request.id} not found`);
+                        error.code = errorCodes.ErrorCode.PARTIAL_BATCH_RESULT;
+                        error.data = batchResult;
+                        inflightRequest.reject(error);
+                    }
+                    else if (payload.error) {
                         const error = new fetch_error.FetchError(payload.error.message);
                         error.code = payload.error.code;
                         error.data = payload.error.data;

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

@@ -34,6 +34,7 @@ export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
     protected detectNetworkFirstRun: boolean;
     protected resetTimer: ReturnType<typeof setTimeout> | null;
     protected lastPerformError: Error | null | unknown;
+    protected lastError: Error | null | unknown;
     constructor(config: SimpleFallbackProviderConfig, logger: LoggerService);
     static _formatter: Formatter | null;
     static getFormatter(): Formatter;
@@ -41,11 +42,12 @@ export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
     getFeeHistory(blockCount: number, newestBlock?: string | null | number, rewardPercentiles?: number[]): Promise<FeeHistory>;
     protected get provider(): FallbackProvider;
     protected switchToNextProvider(): void;
-    protected errorShouldBeReThrown(error: Error | unknown): boolean;
+    protected isNonRetryableError(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;
+    get activeProviderIndex(): number;
 }

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

@@ -19,7 +19,9 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         super(config.network);
         this.detectNetworkFirstRun = true;
         this.resetTimer = null;
-        this.lastPerformError = null;
+        // it is crucial not to mix these two errors
+        this.lastPerformError = null; // last error for 'perform' operations, is batch-oriented
+        this.lastError = null; // last error for whole provider
         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) => {
@@ -103,18 +105,17 @@ 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) &&
-            !errors.isCallExceptionServerError(error));
+    isNonRetryableError(error) {
+        return (!errors.isEthersServerError(error) &&
+            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, (e) => this.errorShouldBeReThrown(e));
+        const retry = retrier.retrier(this.logger, this.config.maxRetries, this.config.minBackoffMs, this.config.maxBackoffMs, this.config.logRetries, (e) => this.isNonRetryableError(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++;
@@ -123,11 +124,12 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                 return await retry(() => this.provider.provider.perform(method, params));
             }
             catch (e) {
-                if (this.errorShouldBeReThrown(e)) {
+                this.lastError = e;
+                // checking that error should not be retried on another provider
+                if (this.isNonRetryableError(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 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
@@ -141,7 +143,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
             }
         }
         const allProvidersFailedError = new allProvidersFailed_error.AllProvidersFailedError('All attempts to do ETH1 RPC request failed');
-        allProvidersFailedError.originalError = lastError;
+        allProvidersFailedError.cause = this.lastError;
         throw allProvidersFailedError;
     }
     async detectNetwork() {
@@ -156,6 +158,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
             else {
                 this.fallbackProviders[index].network = null;
                 this.fallbackProviders[index].unreachable = true;
+                this.lastError = result.reason;
             }
         });
         let previousNetwork = null;
@@ -187,7 +190,9 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
             }
         });
         if (!previousNetwork) {
-            throw new Error('All fallback endpoints are unreachable or all fallback networks differ between each other');
+            const error = new allProvidersFailed_error.AllProvidersFailedError('All fallback endpoints are unreachable or all fallback networks differ between each other');
+            error.cause = this.lastError;
+            throw error;
         }
         if (this.detectNetworkFirstRun) {
             this.detectNetworkFirstRun = false;
@@ -215,6 +220,9 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
     networksEqual(networkA, networkB) {
         return networks.networksEqual(networkA, networkB);
     }
+    get activeProviderIndex() {
+        return this.activeFallbackProviderIndex;
+    }
 };
 exports.SimpleFallbackJsonRpcBatchProvider._formatter = null;
 exports.SimpleFallbackJsonRpcBatchProvider = tslib.__decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lido-nestjs/execution",
-  "version": "1.10.1",
+  "version": "1.11.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",