@lido-nestjs/execution 1.11.1 → 1.13.0

package/dist/common/networks.d.ts

@@ -1,5 +1,7 @@
 import { Network } from '@ethersproject/networks';
 import { Networkish } from '../interfaces/networkish';
+import { ConnectionInfo } from '@ethersproject/web';
 export declare const networksEqual: (networkA: Network, networkB: Network) => boolean;
 export declare const getNetworkChain: (networkish: Networkish) => number;
 export declare const networksChainsEqual: (networkA: Network, networkB: Networkish) => boolean;
+export declare const getConnectionFQDN: (connectionInfo: ConnectionInfo | string) => string;

package/dist/common/networks.js

@@ -2,6 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+const IP_V4_REGEX = new RegExp(/^(?<domain>\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})(?::(?<port>\d+))?/i);
+const DOMAIN_REGEX = new RegExp(/^(?<protocol>https?:\/\/)(?=(?<fqdn>[^:/]+))(?:(?<service>www|ww\d|cdn|ftp|mail|pop\d?|ns\d?|git)\.)?(?:(?<subdomain>[^:/]+)\.)*(?<domain>[^:/]+\.[a-z0-9]+)(?::(?<port>\d+))?(?<path>\/[^?]*)?(?:\?(?<query>[^#]*))?(?:#(?<hash>.*))?/i);
 const networksEqual = (networkA, networkB) => {
     return (networkA.name === networkB.name &&
         networkA.chainId === networkB.chainId &&
@@ -11,8 +13,21 @@ const networksEqual = (networkA, networkB) => {
 const getNetworkChain = (networkish) => typeof networkish === 'object' && networkish != null
     ? networkish.chainId
     : networkish;
-const networksChainsEqual = (networkA, networkB) => networkA.chainId === getNetworkChain(networkB);
+const networksChainsEqual = (networkA, networkB) => networkA.chainId === getNetworkChain(networkB);
+const getConnectionFQDN = (connectionInfo) => {
+    var _a, _b, _c, _d;
+    const urlLike = typeof connectionInfo === 'string' ? connectionInfo : connectionInfo.url;
+    const ipGroups = (_a = urlLike.match(IP_V4_REGEX)) === null || _a === void 0 ? void 0 : _a.groups;
+    if (ipGroups) {
+        /* istanbul ignore next */
+        return (_b = ipGroups.domain) !== null && _b !== void 0 ? _b : '';
+    }
+    const groups = (_c = urlLike.match(DOMAIN_REGEX)) === null || _c === void 0 ? void 0 : _c.groups;
+    /* istanbul ignore next */
+    return (_d = groups === null || groups === void 0 ? void 0 : groups.fqdn) !== null && _d !== void 0 ? _d : '';
+};
 
+exports.getConnectionFQDN = getConnectionFQDN;
 exports.getNetworkChain = getNetworkChain;
 exports.networksChainsEqual = networksChainsEqual;
 exports.networksEqual = networksEqual;

package/dist/ethers/debug-trace-block-by-hash.d.ts

@@ -0,0 +1,4 @@
+import { ExtendedJsonRpcBatchProvider } from '../provider/extended-json-rpc-batch-provider';
+import { SimpleFallbackJsonRpcBatchProvider } from '../provider/simple-fallback-json-rpc-batch-provider';
+import { TraceConfig, TraceResult } from '../interfaces/debug-traces';
+export declare function getDebugTraceBlockByHash(this: ExtendedJsonRpcBatchProvider | SimpleFallbackJsonRpcBatchProvider, blockHash: string, traceConfig: Partial<TraceConfig>): Promise<TraceResult[]>;

package/dist/ethers/debug-trace-block-by-hash.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+async function getDebugTraceBlockByHash(blockHash, traceConfig) {
+    await this.getNetwork();
+    return (await this.perform('getDebugTraceBlockByHash', {
+        blockHash,
+        traceConfig,
+    }));
+}
+
+exports.getDebugTraceBlockByHash = getDebugTraceBlockByHash;

package/dist/events/index.d.ts

@@ -0,0 +1,43 @@
+import { SimpleFallbackJsonRpcBatchProvider } from '../provider/simple-fallback-json-rpc-batch-provider';
+import { AllProvidersFailedError } from '../error';
+import { ExtendedJsonRpcBatchProvider, JsonRpcRequest, JsonRpcResponse } from '../provider/extended-json-rpc-batch-provider';
+export declare type FallbackProviderRequestFailedAllEvent = {
+    action: 'fallback-provider:request:failed:all';
+    provider: SimpleFallbackJsonRpcBatchProvider;
+    error: AllProvidersFailedError;
+};
+export declare type FallbackProviderRequestNonRetryableErrorEvent = {
+    action: 'fallback-provider:request:non-retryable-error';
+    provider: SimpleFallbackJsonRpcBatchProvider;
+    error: Error | unknown;
+};
+export declare type FallbackProviderRequestEvent = {
+    action: 'fallback-provider:request';
+    provider: SimpleFallbackJsonRpcBatchProvider;
+    activeFallbackProviderIndex: number;
+    fallbackProvidersCount: number;
+    domain: string;
+    retryAttempt: number;
+};
+export declare type ProviderResponseBatchedErrorEvent = {
+    action: 'provider:response-batched:error';
+    error: Error;
+    request: JsonRpcRequest[];
+    provider: ExtendedJsonRpcBatchProvider;
+    domain: string;
+};
+export declare type ProviderResponseBatchedEvent = {
+    action: 'provider:response-batched';
+    request: JsonRpcRequest[];
+    response: JsonRpcResponse[] | JsonRpcResponse;
+    provider: ExtendedJsonRpcBatchProvider;
+    domain: string;
+};
+export declare type ProviderRequestBatchedEvent = {
+    action: 'provider:request-batched';
+    request: JsonRpcRequest[];
+    provider: ExtendedJsonRpcBatchProvider;
+    domain: string;
+};
+export declare type ProviderEvents = ProviderRequestBatchedEvent | ProviderResponseBatchedEvent | ProviderResponseBatchedErrorEvent;
+export declare type FallbackProviderEvents = ProviderEvents | FallbackProviderRequestEvent | FallbackProviderRequestNonRetryableErrorEvent | FallbackProviderRequestFailedAllEvent;

package/dist/index.d.ts

@@ -9,3 +9,4 @@ export * from './interfaces/module.options';
 export * from './interfaces/non-empty-array';
 export * from './ethers/fee-history';
 export * from './error';
+export * from './events';

package/dist/interfaces/debug-traces.d.ts

@@ -0,0 +1,27 @@
+export declare type CallType = 'CALL' | 'DELEGATECALL' | 'STATICCALL';
+export declare type TraceResultItem = {
+    from: string;
+    gas: string;
+    gasUsed: string;
+    to: string;
+    input: string;
+    type: string;
+    value?: string;
+    calls?: TraceResultItem[];
+};
+export declare type TraceResult = {
+    txHash?: string;
+    result: TraceResultItem;
+};
+export declare type TraceResponse = {
+    id: number;
+    jsonrpc: string;
+    result: TraceResult[];
+};
+export declare type TraceConfig = {
+    tracer: string;
+    disableStorage: boolean;
+    disableStack: boolean;
+    enableMemory: boolean;
+    enableReturnData: boolean;
+};

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

@@ -10,6 +10,13 @@ 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';
+import { TraceConfig, TraceResult } from '../interfaces/debug-traces';
+import { ProviderEvents } from '../events';
+export interface ExtendedJsonRpcBatchProviderEventEmitter extends NodeJS.EventEmitter {
+    on(eventName: 'rpc', listener: (event: ProviderEvents) => void): this;
+    once(eventName: 'rpc', listener: (event: ProviderEvents) => void): this;
+    addListener(eventName: 'rpc', listener: (event: ProviderEvents) => void): this;
+}
 export interface RequestPolicy {
     jsonRpcMaxBatchSize: number;
     maxConcurrentRequests: number;
@@ -66,14 +73,19 @@ export declare class ExtendedJsonRpcBatchProvider extends JsonRpcProvider {
     protected _concurrencyLimiter: LimitFunction;
     protected _tickCounter: number;
     protected _fetchMiddlewareService: MiddlewareService<Promise<any>>;
+    protected _domain: string;
+    protected _eventEmitter: ExtendedJsonRpcBatchProviderEventEmitter;
     constructor(url: ConnectionInfo | string, network?: Networkish, requestPolicy?: RequestPolicy, fetchMiddlewares?: MiddlewareCallback<Promise<any>>[]);
     static _formatter: Formatter | null;
     static getFormatter(): Formatter;
     protected _batchAggregatorTick(): void;
     protected _startBatchAggregator(): void;
     getFeeHistory(blockCount: number, newestBlock?: string | null | number, rewardPercentiles?: number[]): Promise<FeeHistory>;
+    getDebugTraceBlockByHash(blockHash: string, traceConfig: TraceConfig): Promise<TraceResult[]>;
     prepareRequest(method: string, params: any): [string, Array<any>];
     use(callback: MiddlewareCallback<Promise<any>>): void;
+    get domain(): string;
+    get eventEmitter(): ExtendedJsonRpcBatchProviderEventEmitter;
     send(method: string, params: Array<unknown>): Promise<unknown>;
     detectNetwork(): Promise<Network>;
     protected fetchJson(connection: string | ConnectionInfo, json?: string, processFunc?: (value: any, response: FetchJsonResponse) => any): Promise<any>;

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

@@ -14,6 +14,9 @@ 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');
+var debugTraceBlockByHash = require('../ethers/debug-trace-block-by-hash.js');
+var networks = require('../common/networks.js');
+var events = require('events');
 
 exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extends providers.JsonRpcProvider {
     constructor(url, network, requestPolicy, fetchMiddlewares = []) {
@@ -21,6 +24,8 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
         this._batchAggregator = null;
         this._queue = new queue.Queue();
         this._tickCounter = 0;
+        this._eventEmitter = new events.EventEmitter();
+        this._domain = networks.getConnectionFQDN(url);
         this._requestPolicy = requestPolicy !== null && requestPolicy !== void 0 ? requestPolicy : {
             jsonRpcMaxBatchSize: 200,
             maxConcurrentRequests: 5,
@@ -46,24 +51,29 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
             // if queue size is less then 'jsonRpcMaxBatchSize' - dequeue remaining elements
             const batch = this._queue.dequeueMultiple(this._requestPolicy.jsonRpcMaxBatchSize);
             const batchRequest = batch.map((intent) => intent.request);
-            this.emit('debug', {
-                action: 'requestBatch',
+            const event = {
+                action: 'provider:request-batched',
                 request: properties.deepCopy(batchRequest),
                 provider: this,
-            });
+                domain: this._domain,
+            };
+            this._eventEmitter.emit('rpc', event);
             this._concurrencyLimiter(() => {
                 return this._fetchMiddlewareService.go(() => this.fetchJson(this.connection, JSON.stringify(batchRequest)), {
                     provider: this,
+                    domain: this._domain,
                 });
             })
                 .then((batchResult) => {
                 var _a;
-                this.emit('debug', {
-                    action: 'response',
+                const event = {
+                    action: 'provider:response-batched',
                     request: properties.deepCopy(batchRequest),
                     response: properties.deepCopy(batchResult),
                     provider: this,
-                });
+                    domain: this._domain,
+                };
+                this._eventEmitter.emit('rpc', event);
                 if (!Array.isArray(batchResult)) {
                     const errMessage = 'Unexpected batch result.';
                     const jsonRpcErrorMessage = (_a = batchResult.error) === null || _a === void 0 ? void 0 : _a.message;
@@ -100,24 +110,28 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
                     }
                 });
             }, (error) => {
-                this.emit('debug', {
-                    action: 'response',
+                const event = {
+                    action: 'provider:response-batched:error',
                     error: error,
                     request: properties.deepCopy(batchRequest),
                     provider: this,
-                });
+                    domain: this._domain,
+                };
+                this._eventEmitter.emit('rpc', event);
                 batch.forEach((inflightRequest) => {
                     inflightRequest.reject(error);
                 });
             })
                 .catch((error) => {
                 // catch errors happening in the 'then' callback
-                this.emit('debug', {
-                    action: 'response',
+                const event = {
+                    action: 'provider:response-batched:error',
                     error: error,
                     request: properties.deepCopy(batchRequest),
                     provider: this,
-                });
+                    domain: this._domain,
+                };
+                this._eventEmitter.emit('rpc', event);
                 batch.forEach((inflightRequest) => {
                     inflightRequest.reject(error);
                 });
@@ -140,6 +154,9 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
     async getFeeHistory(blockCount, newestBlock, rewardPercentiles) {
         return feeHistory.getFeeHistory.call(this, blockCount, newestBlock, rewardPercentiles);
     }
+    async getDebugTraceBlockByHash(blockHash, traceConfig) {
+        return debugTraceBlockByHash.getDebugTraceBlockByHash.call(this, blockHash, traceConfig);
+    }
     prepareRequest(method, params) {
         switch (method) {
             case 'getFeeHistory':
@@ -147,6 +164,11 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
                     'eth_feeHistory',
                     [params.blockCount, params.newestBlock, params.rewardPercentiles],
                 ];
+            case 'getDebugTraceBlockByHash':
+                return [
+                    'debug_traceBlockByHash',
+                    [params.blockHash, params.traceConfig],
+                ];
             default:
                 return super.prepareRequest(method, params);
         }
@@ -154,6 +176,12 @@ exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extend
     use(callback) {
         this._fetchMiddlewareService.use(callback);
     }
+    get domain() {
+        return this._domain;
+    }
+    get eventEmitter() {
+        return this._eventEmitter;
+    }
     send(method, params) {
         const request = {
             method: method,

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { BaseProvider, Formatter } from '@ethersproject/providers';
 import { CallOverrides as CallOverridesSource } from '@ethersproject/contracts';
 import { SimpleFallbackProviderConfig } from '../interfaces/simple-fallback-provider-config';
@@ -10,6 +11,8 @@ 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';
+import { TraceConfig, TraceResult } from '../interfaces/debug-traces';
+import { FallbackProviderEvents } from '../events';
 /**
  * EIP-1898 support
  * https://eips.ethereum.org/EIPS/eip-1898
@@ -26,6 +29,11 @@ declare module '@ethersproject/providers' {
         blockTag?: BlockTag;
     }
 }
+export interface SimpleFallbackJsonRpcBatchProviderEventEmitter extends NodeJS.EventEmitter {
+    on(eventName: 'rpc', listener: (event: FallbackProviderEvents) => void): this;
+    once(eventName: 'rpc', listener: (event: FallbackProviderEvents) => void): this;
+    addListener(eventName: 'rpc', listener: (event: FallbackProviderEvents) => void): this;
+}
 export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
     protected config: SimpleFallbackProviderConfig;
     protected logger: LoggerService;
@@ -35,11 +43,13 @@ export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
     protected resetTimer: ReturnType<typeof setTimeout> | null;
     protected lastPerformError: Error | null | unknown;
     protected lastError: Error | null | unknown;
+    protected _eventEmitter: SimpleFallbackJsonRpcBatchProviderEventEmitter;
     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>;
+    getDebugTraceBlockByHash(blockHash: string, traceConfig: Partial<TraceConfig>): Promise<TraceResult[]>;
     protected get provider(): FallbackProvider;
     protected switchToNextProvider(): void;
     protected isNonRetryableError(error: Error | unknown): boolean;
@@ -50,4 +60,5 @@ export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
     protected resetFallbacks(): void;
     protected networksEqual(networkA: Network, networkB: Network): boolean;
     get activeProviderIndex(): number;
+    get eventEmitter(): SimpleFallbackJsonRpcBatchProviderEventEmitter;
 }

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

@@ -13,6 +13,8 @@ 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 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) {
@@ -22,6 +24,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         // 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._eventEmitter = new events.EventEmitter();
         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) => {
@@ -39,6 +42,10 @@ 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 : []);
+            // re-emitting events from fallback-providers
+            provider.eventEmitter.on('rpc', (event) => {
+                this._eventEmitter.emit('rpc', event);
+            });
             return {
                 network: null,
                 provider,
@@ -76,6 +83,9 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
     async getFeeHistory(blockCount, newestBlock, rewardPercentiles) {
         return feeHistory.getFeeHistory.call(this, blockCount, newestBlock, rewardPercentiles);
     }
+    async getDebugTraceBlockByHash(blockHash, traceConfig) {
+        return debugTraceBlockByHash.getDebugTraceBlockByHash.call(this, blockHash, traceConfig);
+    }
     get provider() {
         if (this.activeFallbackProviderIndex > this.fallbackProviders.length - 1) {
             this.activeFallbackProviderIndex = 0;
@@ -118,15 +128,35 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         // maximum number of switching is limited to total fallback provider count
         while (attempt < this.fallbackProviders.length) {
             try {
+                let performRetryAttempt = 0;
                 attempt++;
                 // awaiting is extremely important here
                 // without it, the error will not be caught in current try-catch scope
-                return await retry(() => this.provider.provider.perform(method, params));
+                return await retry(() => {
+                    const provider = this.provider;
+                    const event = {
+                        action: 'fallback-provider:request',
+                        provider: this,
+                        activeFallbackProviderIndex: this.activeFallbackProviderIndex,
+                        fallbackProvidersCount: this.fallbackProviders.length,
+                        domain: provider.provider.domain,
+                        retryAttempt: performRetryAttempt,
+                    };
+                    this._eventEmitter.emit('rpc', event);
+                    performRetryAttempt++;
+                    return provider.provider.perform(method, params);
+                });
             }
             catch (e) {
                 this.lastError = e;
                 // checking that error should not be retried on another provider
                 if (this.isNonRetryableError(e)) {
+                    const event = {
+                        action: 'fallback-provider:request:non-retryable-error',
+                        provider: this,
+                        error: e,
+                    };
+                    this._eventEmitter.emit('rpc', event);
                     throw e;
                 }
                 this.logger.error('Error while doing ETH1 RPC request. Will try to switch to another provider');
@@ -144,6 +174,12 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         }
         const allProvidersFailedError = new allProvidersFailed_error.AllProvidersFailedError('All attempts to do ETH1 RPC request failed');
         allProvidersFailedError.cause = this.lastError;
+        const event = {
+            action: 'fallback-provider:request:failed:all',
+            provider: this,
+            error: allProvidersFailedError,
+        };
+        this._eventEmitter.emit('rpc', event);
         throw allProvidersFailedError;
     }
     async detectNetwork() {
@@ -223,6 +259,9 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
     get activeProviderIndex() {
         return this.activeFallbackProviderIndex;
     }
+    get eventEmitter() {
+        return this._eventEmitter;
+    }
 };
 exports.SimpleFallbackJsonRpcBatchProvider._formatter = null;
 exports.SimpleFallbackJsonRpcBatchProvider = tslib.__decorate([

package/package.json

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