@lido-nestjs/execution 1.14.2 → 1.16.0

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

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

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

@@ -6,4 +6,5 @@ exports.ErrorCode = void 0;
 (function (ErrorCode) {
     ErrorCode["UNEXPECTED_BATCH_RESULT"] = "UNEXPECTED_BATCH_RESULT";
     ErrorCode["PARTIAL_BATCH_RESULT"] = "PARTIAL_BATCH_RESULT";
+    ErrorCode["REQUEST_TIMEOUT"] = "REQUEST_TIMEOUT";
 })(exports.ErrorCode || (exports.ErrorCode = {}));

package/dist/error/index.d.ts

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

package/dist/error/request-timeout.error.d.ts

@@ -0,0 +1,5 @@
+export declare class RequestTimeoutError extends Error {
+    name: string;
+    timeoutMs: number;
+    constructor(message: string, timeoutMs: number);
+}

package/dist/error/request-timeout.error.js

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

package/dist/index.js

@@ -11,6 +11,7 @@ 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');
+var requestTimeout_error = require('./error/request-timeout.error.js');
 
 
 
@@ -37,3 +38,4 @@ exports.getFeeHistory = feeHistory.getFeeHistory;
 exports.AllProvidersFailedError = allProvidersFailed_error.AllProvidersFailedError;
 exports.FetchError = fetch_error.FetchError;
 exports.NoNewBlocksWhilePollingError = noNewBlocksWhilePolling_error.NoNewBlocksWhilePollingError;
+exports.RequestTimeoutError = requestTimeout_error.RequestTimeoutError;

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

@@ -14,4 +14,6 @@ export interface SimpleFallbackProviderConfig {
     resetIntervalMs?: number;
     fetchMiddlewares?: MiddlewareCallback<Promise<any>>[];
     maxTimeWithoutNewBlocksMs?: number;
+    requestTimeoutMs?: number;
+    instanceLabel?: string;
 }

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

@@ -46,12 +46,14 @@ export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
     constructor(config: SimpleFallbackProviderConfig, logger: LoggerService);
     static _formatter: Formatter | null;
     static getFormatter(): Formatter;
+    protected formatLog(message: string, providerIndex?: number): string;
     on(eventName: EventType, listener: Listener): this;
     getFeeHistory(blockCount: number, newestBlock?: string | null | number, rewardPercentiles?: number[]): Promise<FeeHistory>;
     getDebugTraceBlockByHash(blockHash: string, traceConfig: Partial<TraceConfig>): Promise<TraceResult[]>;
     protected get provider(): FallbackProvider;
     protected switchToNextProvider(): void;
     protected isNonRetryableError(error: Error | unknown): boolean;
+    protected withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T>;
     perform(method: string, params: {
         [name: string]: unknown;
     }): Promise<unknown>;

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

@@ -12,12 +12,14 @@ 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 requestTimeout_error = require('../error/request-timeout.error.js');
 var feeHistory = require('../ethers/fee-history.js');
 var debugTraceBlockByHash = require('../ethers/debug-trace-block-by-hash.js');
 var events = require('events');
 
 exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchProvider extends providers.BaseProvider {
     constructor(config, logger) {
+        var _a;
         super(config.network);
         this.detectNetworkFirstRun = true;
         this.resetTimer = null;
@@ -54,6 +56,22 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
             };
         });
         this.activeFallbackProviderIndex = 0;
+        // Log initialization info
+        const configInfo = {
+            providers: conns.length,
+            network: this.config.network,
+            requestPolicy: this.config.requestPolicy,
+            maxRetries: this.config.maxRetries,
+            minBackoffMs: this.config.minBackoffMs,
+            maxBackoffMs: this.config.maxBackoffMs,
+            logRetries: this.config.logRetries,
+            resetIntervalMs: this.config.resetIntervalMs,
+            fetchMiddlewares: ((_a = this.config.fetchMiddlewares) === null || _a === void 0 ? void 0 : _a.length) || 0,
+            maxTimeWithoutNewBlocksMs: this.config.maxTimeWithoutNewBlocksMs,
+            requestTimeoutMs: this.config.requestTimeoutMs || 'disabled',
+            instanceLabel: this.config.instanceLabel || 'none',
+        };
+        this.logger.log(this.formatLog(`Initialized SimpleFallbackJsonRpcBatchProvider: ${JSON.stringify(configInfo)}`));
     }
     static getFormatter() {
         if (this._formatter == null) {
@@ -61,6 +79,19 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         }
         return this._formatter;
     }
+    formatLog(message, providerIndex) {
+        const parts = [];
+        if (this.config.instanceLabel) {
+            parts.push(`[${this.config.instanceLabel}]`);
+        }
+        if (providerIndex !== undefined) {
+            parts.push(`[provider:${providerIndex}]`);
+        }
+        if (parts.length > 0) {
+            return `${parts.join('')} ${message}`;
+        }
+        return message;
+    }
     on(eventName, listener) {
         let dieTimer = null;
         const startDieTimer = (latestObservedBlockNumber) => {
@@ -109,17 +140,29 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
     }
     switchToNextProvider() {
         if (this.fallbackProviders.length === 1) {
-            this.logger.warn('Will not switch to next provider. No valid backup provider provided.');
+            this.logger.warn(this.formatLog('Will not switch to next provider. No valid backup provider provided.'));
             return;
         }
-        this.activeFallbackProviderIndex++;
-        this.logger.log(`Switched to next provider for execution layer`);
+        const oldIndex = this.activeFallbackProviderIndex;
+        this.activeFallbackProviderIndex =
+            (this.activeFallbackProviderIndex + 1) % this.fallbackProviders.length;
+        this.logger.log(this.formatLog(`Switched provider: [${oldIndex}] -> [${this.activeFallbackProviderIndex}] (total: ${this.fallbackProviders.length})`));
     }
     isNonRetryableError(error) {
         return (!errors.isEthersServerError(error) &&
             errors.isErrorHasCode(error) &&
             errors.nonRetryableErrors.includes(error.code));
     }
+    withTimeout(promise, timeoutMs) {
+        return Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new requestTimeout_error.RequestTimeoutError(`Request timeout after ${timeoutMs}ms`, timeoutMs));
+                }, timeoutMs);
+            }),
+        ]);
+    }
     async perform(method, params) {
         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;
@@ -130,9 +173,11 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
             try {
                 let performRetryAttempt = 0;
                 attempt++;
+                // Log which provider we're attempting to use
+                this.logger.log(this.formatLog(`Attempting request (attempt ${attempt}/${this.fallbackProviders.length})`, this.activeFallbackProviderIndex));
                 // awaiting is extremely important here
                 // without it, the error will not be caught in current try-catch scope
-                return await retry(() => {
+                const result = await retry(() => {
                     const provider = this.provider;
                     const event = {
                         action: 'fallback-provider:request',
@@ -144,8 +189,16 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                     };
                     this._eventEmitter.emit('rpc', event);
                     performRetryAttempt++;
-                    return provider.provider.perform(method, params);
+                    const performPromise = provider.provider.perform(method, params);
+                    // Apply timeout if configured
+                    if (this.config.requestTimeoutMs) {
+                        return this.withTimeout(performPromise, this.config.requestTimeoutMs);
+                    }
+                    return performPromise;
                 });
+                // Log successful request
+                this.logger.log(this.formatLog(`Request successful after ${performRetryAttempt} retry attempt(s)`, this.activeFallbackProviderIndex));
+                return result;
             }
             catch (e) {
                 this.lastError = e;
@@ -157,10 +210,22 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                         error: e,
                     };
                     this._eventEmitter.emit('rpc', event);
+                    // Log context (label + provider index) synchronously before error object
+                    // to ensure proper ordering in async logging systems
+                    this.logger.error(this.formatLog(`Non-retryable error occurred`, this.activeFallbackProviderIndex));
+                    this.logger.error(e);
                     throw e;
                 }
-                this.logger.error('Error while doing ETH1 RPC request. Will try to switch to another provider');
-                this.logger.error(e);
+                // Log context (label + provider index) synchronously before error object
+                // to ensure proper ordering in async logging systems
+                if (e instanceof requestTimeout_error.RequestTimeoutError) {
+                    this.logger.error(this.formatLog(`Request timeout after ${e.timeoutMs}ms. Will switch to next provider.`, this.activeFallbackProviderIndex));
+                    this.logger.error(e);
+                }
+                else {
+                    this.logger.error(this.formatLog(`Error occurred. Will switch to next provider.`, this.activeFallbackProviderIndex));
+                    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
                 // that request fails and throws `Error`. This `Error` is bubbled N times to corresponding `perform` calls.
@@ -218,7 +283,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                     if (this.detectNetworkFirstRun) {
                         throw new Error(`Fallback provider [${index}] network is different to other provider's networks`);
                     }
-                    this.logger.warn(`Fallback provider [${index}] network is different to other provider's networks`);
+                    this.logger.warn(this.formatLog(`Fallback provider [${index}] network is different to other provider's networks`));
                 }
             }
             else {
@@ -245,7 +310,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         if (this.resetTimer) {
             clearTimeout(this.resetTimer);
         }
-        this.fallbackProviders.forEach((fallbackProvider, index) => {
+        this.fallbackProviders.forEach((_, index) => {
             var _a;
             if (!((_a = this.fallbackProviders[index].network) === null || _a === void 0 ? void 0 : _a.chainId)) {
                 this.fallbackProviders[index].unreachable = false;

package/package.json

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