@lido-nestjs/execution 1.20.0 → 1.22.0

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

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

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

@@ -75,7 +75,8 @@ export declare class ExtendedJsonRpcBatchProvider extends JsonRpcProvider {
     protected _fetchMiddlewareService: MiddlewareService<Promise<any>>;
     protected _domain: string;
     protected _eventEmitter: ExtendedJsonRpcBatchProviderEventEmitter;
-    constructor(url: ConnectionInfo | string, network?: Networkish, requestPolicy?: RequestPolicy, fetchMiddlewares?: MiddlewareCallback<Promise<any>>[]);
+    protected _requestTimeoutMs?: number;
+    constructor(url: ConnectionInfo | string, network?: Networkish, requestPolicy?: RequestPolicy, fetchMiddlewares?: MiddlewareCallback<Promise<any>>[], requestTimeoutMs?: number);
     static _formatter: Formatter | null;
     static getFormatter(): Formatter;
     protected _batchAggregatorTick(): void;

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

@@ -15,14 +15,16 @@ var errorCodes = require('../error/codes/error-codes.js');
 var debugTraceBlockByHash = require('../ethers/debug-trace-block-by-hash.js');
 var networks = require('../common/networks.js');
 var sanitizeError = require('../common/sanitize-error.js');
+var requestTimeout_error = require('../error/request-timeout.error.js');
 var lazyEventEmitter = require('../common/lazy-event-emitter.js');
 
 exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extends providers.JsonRpcProvider {
-    constructor(url, network, requestPolicy, fetchMiddlewares = []) {
+    constructor(url, network, requestPolicy, fetchMiddlewares = [], requestTimeoutMs) {
         super(url, network);
         this._batchAggregator = null;
         this._queue = new queue.Queue();
         this._tickCounter = 0;
+        this._requestTimeoutMs = requestTimeoutMs;
         this._eventEmitter = new lazyEventEmitter.LazyEventEmitter();
         this._domain = networks.getConnectionFQDN(url);
         this._requestPolicy = requestPolicy !== null && requestPolicy !== void 0 ? requestPolicy : {
@@ -189,12 +191,22 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
         };
         const currentRequest = {
             request,
-            reject: null,
             resolve: null,
+            reject: null,
         };
+        let timerId;
         const promise = new Promise((resolve, reject) => {
             currentRequest.resolve = resolve;
             currentRequest.reject = reject;
+            if (this._requestTimeoutMs) {
+                const timeoutMs = this._requestTimeoutMs;
+                timerId = setTimeout(() => {
+                    reject(new requestTimeout_error.RequestTimeoutError(`Request timeout after ${timeoutMs}ms`, timeoutMs));
+                }, timeoutMs);
+            }
+        }).finally(() => {
+            if (timerId)
+                clearTimeout(timerId);
         });
         this._queue.enqueue(currentRequest);
         this._startBatchAggregator();
@@ -220,5 +232,5 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
 exports.ExtendedJsonRpcBatchProvider._formatter = null;
 exports.ExtendedJsonRpcBatchProvider = tslib.__decorate([
     common.Injectable(),
-    tslib.__metadata("design:paramtypes", [Object, Object, Object, Array])
+    tslib.__metadata("design:paramtypes", [Object, Object, Object, Array, Number])
 ], exports.ExtendedJsonRpcBatchProvider);

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

@@ -55,7 +55,6 @@ export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
     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

@@ -30,7 +30,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         this._childRpcListenersAttached = false;
         this._eventEmitter = new lazyEventEmitter.LazyEventEmitter();
         this._setupLazyChildListeners();
-        this.config = Object.assign({ maxRetries: 3, minBackoffMs: 500, maxBackoffMs: 5000, logRetries: true, resetIntervalMs: 10000, maxTimeWithoutNewBlocksMs: 60000 }, config);
+        this.config = Object.assign({ maxRetries: 3, minBackoffMs: 500, maxBackoffMs: 5000, logRetries: true, logSuccessfulAttempts: true, resetIntervalMs: 10000, maxTimeWithoutNewBlocksMs: 60000 }, config);
         this.logger = logger;
         const conns = config.urls.filter((url) => {
             if (!url) {
@@ -46,7 +46,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         }
         this.fallbackProviders = conns.map((conn, index) => {
             var _a;
-            const provider = new extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider(conn, undefined, config.requestPolicy, (_a = config.fetchMiddlewares) !== null && _a !== void 0 ? _a : []);
+            const provider = new extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider(conn, undefined, config.requestPolicy, (_a = config.fetchMiddlewares) !== null && _a !== void 0 ? _a : [], config.requestTimeoutMs);
             return {
                 network: null,
                 provider,
@@ -152,16 +152,6 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
             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) {
         var _a, _b;
         const retry = retrier.retrier(this.logger, this.config.maxRetries, this.config.minBackoffMs, this.config.maxBackoffMs, this.config.logRetries, (e) => this.isNonRetryableError(e));
@@ -175,7 +165,9 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                 let performRetryAttempt = 0;
                 attempt++;
                 // Log which provider we're attempting to use
-                this.logger.log(this.formatLog(`Attempting ${method} (attempt ${attempt}/${this.fallbackProviders.length})`, this.activeFallbackProviderIndex));
+                if (this.config.logSuccessfulAttempts) {
+                    this.logger.log(this.formatLog(`Attempting ${method} (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
                 const result = await retry(() => {
@@ -189,15 +181,12 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                         retryAttempt: performRetryAttempt,
                     }));
                     performRetryAttempt++;
-                    const performPromise = provider.provider.perform(method, params);
-                    // Apply timeout if configured
-                    if (this.config.requestTimeoutMs) {
-                        return this.withTimeout(performPromise, this.config.requestTimeoutMs);
-                    }
-                    return performPromise;
+                    return provider.provider.perform(method, params);
                 });
                 // Log successful request
-                this.logger.log(this.formatLog(`${method} successful after ${performRetryAttempt} retry attempt(s)`, this.activeFallbackProviderIndex));
+                if (this.config.logSuccessfulAttempts) {
+                    this.logger.log(this.formatLog(`${method} successful after ${performRetryAttempt} retry attempt(s)`, this.activeFallbackProviderIndex));
+                }
                 return result;
             }
             catch (e) {

package/package.json

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