@lido-nestjs/execution 1.19.0 → 1.21.0

package/dist/common/retrier.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var sleep = require('./sleep.js');
+var sanitizeError = require('./sanitize-error.js');
 
 const retrier = (logger, defaultMaxRetryCount = 3, defaultMinBackoffMs = 1000, defaultMaxBackoffMs = 60000, defaultLogWarning = false, defaultErrorFilter) => {
     return async (callback, maxRetryCount, minBackoffMs, maxBackoffMs, logWarning, errorFilter) => {
@@ -17,7 +18,7 @@ const retrier = (logger, defaultMaxRetryCount = 3, defaultMinBackoffMs = 1000, d
                 throw err;
             }
             if (logger && logWarning) {
-                logger.warn(err, `Retrying after (${minBackoffMs}ms). Remaining retries [${maxRetryCount}]`);
+                logger.warn(sanitizeError.sanitizeError(err), `Retrying after (${minBackoffMs}ms). Remaining retries [${maxRetryCount}]`);
             }
             if (maxRetryCount <= 1 || minBackoffMs >= maxBackoffMs) {
                 throw err;

package/dist/common/sanitize-error.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Returns a safe, bounded string representation of an error for logging.
+ * inspect() handles everything internally: circular references, throwing
+ * getters, frozen objects, huge nested data. No manual field extraction needed.
+ */
+export declare function sanitizeError(error: unknown, maxLength?: number): string;
+/**
+ * Truncates unknown data to a safe size.
+ * Use for FetchError.data assignment to prevent huge RPC payloads
+ * from being attached to error objects.
+ */
+export declare function sanitizeErrorData(data: unknown, maxLength?: number): unknown;
+/**
+ * Mutates the error object in place, truncating heavy fields.
+ * Preserves the original error type (instanceof checks still work).
+ * Use for error objects that are thrown to consumers (e.g. AllProvidersFailedError.cause).
+ */
+export declare function sanitizeErrorInPlace(error: unknown, maxLength?: number, 
+/** @internal tracks visited objects to prevent circular-reference stack overflow */
+_seen?: WeakSet<object>): void;

package/dist/common/sanitize-error.js

@@ -0,0 +1,113 @@
+'use strict';
+
+var util = require('util');
+
+const DEFAULT_MAX_LENGTH = 1000;
+const INSPECT_OPTIONS = (maxLength) => ({
+    depth: 4,
+    maxStringLength: maxLength,
+    maxArrayLength: 20,
+    compact: true,
+    breakLength: Infinity,
+});
+/**
+ * Uses util.inspect to produce a bounded string representation.
+ * Never calls JSON.stringify (avoids V8 "RangeError: Invalid string length"
+ * on objects >512 MB). inspect() handles circular references, throwing
+ * getters, frozen objects, and huge data internally.
+ */
+function truncate(value, maxLength) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === 'string') {
+        return value.length > maxLength
+            ? value.slice(0, maxLength) +
+                `...[truncated, total length: ${value.length}]`
+            : value;
+    }
+    if (typeof value !== 'object')
+        return value;
+    try {
+        const inspected = util.inspect(value, INSPECT_OPTIONS(maxLength));
+        if (inspected.length <= maxLength)
+            return value;
+        return (inspected.slice(0, maxLength) +
+            `...[truncated, total length: ${inspected.length}]`);
+    }
+    catch (_a) {
+        return '[unserializable]';
+    }
+}
+/**
+ * Returns a safe, bounded string representation of an error for logging.
+ * inspect() handles everything internally: circular references, throwing
+ * getters, frozen objects, huge nested data. No manual field extraction needed.
+ */
+function sanitizeError(error, maxLength = DEFAULT_MAX_LENGTH) {
+    try {
+        const result = util.inspect(error, INSPECT_OPTIONS(maxLength));
+        if (result.length <= maxLength)
+            return result;
+        return (result.slice(0, maxLength) +
+            `...[truncated, total length: ${result.length}]`);
+    }
+    catch (_a) {
+        return '[unserializable error]';
+    }
+}
+/**
+ * Truncates unknown data to a safe size.
+ * Use for FetchError.data assignment to prevent huge RPC payloads
+ * from being attached to error objects.
+ */
+function sanitizeErrorData(data, maxLength = DEFAULT_MAX_LENGTH) {
+    return truncate(data, maxLength);
+}
+const HEAVY_FIELDS = ['data', 'body', 'requestBody', 'serverError'];
+/**
+ * Mutates the error object in place, truncating heavy fields.
+ * Preserves the original error type (instanceof checks still work).
+ * Use for error objects that are thrown to consumers (e.g. AllProvidersFailedError.cause).
+ */
+function sanitizeErrorInPlace(error, maxLength = DEFAULT_MAX_LENGTH, 
+/** @internal tracks visited objects to prevent circular-reference stack overflow */
+_seen) {
+    if (error === null || error === undefined || typeof error !== 'object') {
+        return;
+    }
+    const seen = _seen !== null && _seen !== void 0 ? _seen : new WeakSet();
+    if (seen.has(error))
+        return;
+    seen.add(error);
+    const err = error;
+    for (const field of HEAVY_FIELDS) {
+        try {
+            if (err[field] !== undefined) {
+                err[field] = truncate(err[field], maxLength);
+            }
+        }
+        catch (_a) {
+            // read-only property or throwing getter
+        }
+    }
+    try {
+        if (err.error && typeof err.error === 'object') {
+            sanitizeErrorInPlace(err.error, maxLength, seen);
+        }
+    }
+    catch (_b) {
+        // throwing getter on .error
+    }
+    try {
+        if (err.cause && typeof err.cause === 'object') {
+            sanitizeErrorInPlace(err.cause, maxLength, seen);
+        }
+    }
+    catch (_c) {
+        // throwing getter on .cause
+    }
+}
+
+exports.sanitizeError = sanitizeError;
+exports.sanitizeErrorData = sanitizeErrorData;
+exports.sanitizeErrorInPlace = sanitizeErrorInPlace;

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

@@ -14,14 +14,17 @@ var feeHistory = require('../ethers/fee-history.js');
 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 : {
@@ -77,7 +80,7 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
                         : '';
                     const error = new fetch_error.FetchError(errMessage + detailedMessage);
                     error.code = errorCodes.ErrorCode.UNEXPECTED_BATCH_RESULT;
-                    error.data = batchResult.error;
+                    error.data = sanitizeError.sanitizeErrorData(batchResult.error);
                     throw error;
                 }
                 const resultMap = batchResult.reduce((resultMap, payload) => {
@@ -101,7 +104,7 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
                     else if (payload.error) {
                         const error = new fetch_error.FetchError(payload.error.message);
                         error.code = payload.error.code;
-                        error.data = payload.error.data;
+                        error.data = sanitizeError.sanitizeErrorData(payload.error.data);
                         inflightRequest.reject(error);
                     }
                     else {
@@ -188,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();
@@ -219,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

@@ -12,6 +12,7 @@ var noNewBlocksWhilePolling_error = require('../error/no-new-blocks-while-pollin
 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 sanitizeError = require('../common/sanitize-error.js');
 var transactionWaitTimeout_error = require('../error/transaction-wait-timeout.error.js');
 var feeHistory = require('../ethers/fee-history.js');
 var debugTraceBlockByHash = require('../ethers/debug-trace-block-by-hash.js');
@@ -45,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,
@@ -151,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));
@@ -188,12 +179,7 @@ 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));
@@ -211,18 +197,18 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                     // Log context (label + provider index) synchronously before error object
                     // to ensure proper ordering in async logging systems
                     this.logger.error(this.formatLog(`${method} non-retryable error occurred`, this.activeFallbackProviderIndex));
-                    this.logger.error(e);
+                    this.logger.error(sanitizeError.sanitizeError(e));
                     throw 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(`${method} timeout after ${e.timeoutMs}ms. Will switch to next provider.`, this.activeFallbackProviderIndex));
-                    this.logger.error(e);
+                    this.logger.error(sanitizeError.sanitizeError(e));
                 }
                 else {
                     this.logger.error(this.formatLog(`${method} error occurred. Will switch to next provider.`, this.activeFallbackProviderIndex));
-                    this.logger.error(e);
+                    this.logger.error(sanitizeError.sanitizeError(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
@@ -236,6 +222,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
             }
         }
         const allProvidersFailedError = new allProvidersFailed_error.AllProvidersFailedError(`All attempts to do ETH1 RPC request failed for ${method}`);
+        sanitizeError.sanitizeErrorInPlace(this.lastError);
         allProvidersFailedError.cause = this.lastError;
         this._eventEmitter.emitLazy('rpc', () => ({
             action: 'fallback-provider:request:failed:all',
@@ -389,7 +376,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
             catch (error) {
                 // All providers failed - log and retry until timeout
                 lastError = error;
-                this.logger.warn(this.formatLog(`waitForTransactionWithFallback poll #${pollCount} failed for ${txHash}: ${error}`));
+                this.logger.warn(this.formatLog(`waitForTransactionWithFallback poll #${pollCount} failed for ${txHash}`), sanitizeError.sanitizeError(error));
                 await sleep.sleep(pollInterval);
             }
         }

package/package.json

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