@lido-nestjs/execution 1.0.0

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Lido
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# Execution layer (Eth1 RPC Provider)
+
+NestJS Logger for Lido Finance projects.
+Part of [Lido NestJS Modules](https://github.com/lidofinance/lido-nestjs-modules/#readme)
+
+## Install
+
+```bash
+yarn add @lido-nestjs/execution
+```
+
+## Usage
+
+### Basic usage
+
+```ts
+// Import
+import { Injectable, Module } from '@nestjs/common';
+import { ExecutionModule } from '@lido-nestjs/execution';
+import { MyService } from './my.service';
+
+@Module({
+  imports: [
+    LoggerModule.forRoot({}),
+    ExecutionModule.forRoot({
+      imports: [],
+      urls: ['http://localhost:8545', 'http://fallback:8545'],
+      network: 1,
+    }),
+  ],
+  providers: [MyService],
+  exports: [MyService],
+})
+export class MyModule {}
+
+// Usage
+import { SimpleFallbackJsonRpcBatchProvider } from '@lido-nestjs/execution';
+
+@Injectable
+export class MyService {
+  constructor(private provider: SimpleFallbackJsonRpcBatchProvider) {}
+
+  async doSomeWork() {
+    return await this.provider.getBlock(1000);
+  }
+}
+```
+
+### Async usage
+
+// TODO

package/dist/common/networks.d.ts

@@ -0,0 +1,5 @@
+import { Network } from '@ethersproject/networks';
+import { Networkish } from '../interfaces/networkish';
+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;

package/dist/common/networks.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const networksEqual = (networkA, networkB) => {
+    return (networkA.name === networkB.name &&
+        networkA.chainId === networkB.chainId &&
+        (networkA.ensAddress === networkB.ensAddress ||
+            (!networkA.ensAddress && !networkB.ensAddress)));
+};
+const getNetworkChain = (networkish) => typeof networkish === 'object' && networkish != null
+    ? networkish.chainId
+    : networkish;
+const networksChainsEqual = (networkA, networkB) => networkA.chainId === getNetworkChain(networkB);
+
+exports.getNetworkChain = getNetworkChain;
+exports.networksChainsEqual = networksChainsEqual;
+exports.networksEqual = networksEqual;

package/dist/common/promise-limit.d.ts

@@ -0,0 +1,7 @@
+export interface LimitFunction {
+    readonly activeCount: number;
+    readonly pendingCount: number;
+    clearQueue: () => void;
+    <Arguments extends unknown[], ReturnType>(fn: (...args: Arguments) => PromiseLike<ReturnType> | ReturnType, ...args: Arguments): Promise<ReturnType>;
+}
+export default function pLimit(concurrency: number): LimitFunction;

package/dist/common/promise-limit.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var queue = require('./queue.js');
+
+/* eslint-disable @typescript-eslint/ban-types */
+function pLimit(concurrency) {
+    if (!((Number.isInteger(concurrency) ||
+        concurrency === Number.POSITIVE_INFINITY) &&
+        concurrency > 0)) {
+        throw new TypeError('Expected `concurrency` to be positive integer');
+    }
+    const queue$1 = new queue.Queue();
+    let activeCount = 0;
+    const next = () => {
+        activeCount--;
+        if (queue$1.length > 0) {
+            const item = queue$1.dequeue();
+            item && item();
+        }
+    };
+    const run = async (fn, resolve, args) => {
+        activeCount++;
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+            await result;
+        }
+        catch (_a) {
+            // should not catch exceptions here
+            // exceptions should be caught in above handlers
+        }
+        next();
+    };
+    const enqueue = (fn, resolve, args) => {
+        queue$1.enqueue(run.bind(undefined, fn, resolve, args));
+        (async () => {
+            await Promise.resolve();
+            if (activeCount < concurrency && queue$1.length > 0) {
+                const item = queue$1.dequeue();
+                item && item();
+            }
+        })();
+    };
+    const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, args);
+    });
+    Object.defineProperties(generator, {
+        activeCount: {
+            get: () => activeCount,
+        },
+        pendingCount: {
+            get: () => queue$1.length,
+        },
+        clearQueue: {
+            value: () => {
+                queue$1.clear();
+            },
+        },
+    });
+    return generator;
+}
+
+exports["default"] = pLimit;

package/dist/common/queue.d.ts

@@ -0,0 +1,8 @@
+export declare class Queue<T> {
+    private _store;
+    enqueue(val: T): void;
+    dequeue(): T | undefined;
+    get length(): number;
+    clear(): void;
+    dequeueMultiple(batch: number): T[];
+}

package/dist/common/queue.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class Queue {
+    constructor() {
+        this._store = [];
+    }
+    enqueue(val) {
+        this._store.push(val);
+    }
+    dequeue() {
+        return this._store.shift();
+    }
+    get length() {
+        return this._store.length;
+    }
+    clear() {
+        this._store = [];
+    }
+    dequeueMultiple(batch) {
+        batch = (batch | 0) > 0 ? batch | 0 : 1;
+        const buffer = [];
+        for (let i = 0; i < batch; i++) {
+            const value = this.dequeue();
+            if (typeof value === 'undefined') {
+                break;
+            }
+            buffer.push(value);
+        }
+        return buffer;
+    }
+}
+
+exports.Queue = Queue;

package/dist/common/retrier.d.ts

@@ -0,0 +1,2 @@
+import { LoggerService } from '@nestjs/common/services/logger.service';
+export declare const retrier: (logger?: LoggerService | null | undefined, defaultMaxRetryCount?: number, defaultMinBackoffMs?: number, defaultMaxBackoffMs?: number, defaultLogWarning?: boolean) => <T extends unknown>(callback: () => T | Promise<T>, maxRetryCount?: number | undefined, minBackoffMs?: number | undefined, maxBackoffMs?: number | undefined, logWarning?: boolean | undefined) => Promise<T>;

package/dist/common/retrier.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sleep = require('./sleep.js');
+
+const retrier = (logger, defaultMaxRetryCount = 3, defaultMinBackoffMs = 1000, defaultMaxBackoffMs = 60000, defaultLogWarning = false) => {
+    return async (callback, maxRetryCount, minBackoffMs, maxBackoffMs, logWarning) => {
+        maxRetryCount = maxRetryCount !== null && maxRetryCount !== void 0 ? maxRetryCount : defaultMaxRetryCount;
+        minBackoffMs = minBackoffMs !== null && minBackoffMs !== void 0 ? minBackoffMs : defaultMinBackoffMs;
+        maxBackoffMs = maxBackoffMs !== null && maxBackoffMs !== void 0 ? maxBackoffMs : defaultMaxBackoffMs;
+        logWarning = logWarning !== null && logWarning !== void 0 ? logWarning : defaultLogWarning;
+        try {
+            return await callback();
+        }
+        catch (err) {
+            if (logger && logWarning) {
+                logger.warn(err, 'Retrying after (%dms). Remaining retries [%d]', minBackoffMs, maxRetryCount);
+            }
+            if (maxRetryCount <= 1 || minBackoffMs >= maxBackoffMs) {
+                throw err;
+            }
+            await sleep.sleep(minBackoffMs);
+            return await retrier(logger)(callback, maxRetryCount - 1, minBackoffMs * 2, maxBackoffMs, logWarning);
+        }
+    };
+};
+
+exports.retrier = retrier;

package/dist/common/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<unknown>;

package/dist/common/sleep.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+exports.sleep = sleep;

package/dist/constants/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const EXECUTION_MODULE_OPTIONS: unique symbol;
+export declare enum Provider {
+    ExtendedJsonRpcBatchProvider = 0,
+    SimpleFallbackJsonRpcBatchProvider = 1
+}

package/dist/constants/constants.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const EXECUTION_MODULE_OPTIONS = Symbol('execution-module-options');
+exports.Provider = void 0;
+(function (Provider) {
+    Provider[Provider["ExtendedJsonRpcBatchProvider"] = 0] = "ExtendedJsonRpcBatchProvider";
+    Provider[Provider["SimpleFallbackJsonRpcBatchProvider"] = 1] = "SimpleFallbackJsonRpcBatchProvider";
+})(exports.Provider || (exports.Provider = {}));
+// export type Providers =
+//   [Provider.ExtendedJsonRpcBatchProvider, Provider.SimpleFallbackJsonRpcBatchProvider] |
+//   [Provider.SimpleFallbackJsonRpcBatchProvider, Provider.ExtendedJsonRpcBatchProvider] |
+//   [Provider.SimpleFallbackJsonRpcBatchProvider] |
+//   [Provider.ExtendedJsonRpcBatchProvider];
+
+exports.EXECUTION_MODULE_OPTIONS = EXECUTION_MODULE_OPTIONS;

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

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

package/dist/error/fetch.error.js

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

package/dist/ethers/block-tag.d.ts

@@ -0,0 +1,6 @@
+export declare type BlockTag = string | number | {
+    blockNumber: string;
+} | {
+    blockHash: string;
+    requireCanonical?: boolean;
+};

package/dist/ethers/formatter-with-eip1898.d.ts

@@ -0,0 +1,8 @@
+import { Formatter } from '@ethersproject/providers';
+export declare class FormatterWithEIP1898 extends Formatter {
+    /**
+     * blockTag formatter with EIP-1898 support
+     * https://eips.ethereum.org/EIPS/eip-1898
+     */
+    blockTag(blockTag: any): any;
+}

package/dist/ethers/formatter-with-eip1898.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var providers = require('@ethersproject/providers');
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+class FormatterWithEIP1898 extends providers.Formatter {
+    /**
+     * blockTag formatter with EIP-1898 support
+     * https://eips.ethereum.org/EIPS/eip-1898
+     */
+    blockTag(blockTag) {
+        if (typeof blockTag === 'object' &&
+            blockTag != null &&
+            (blockTag.blockNumber || blockTag.blockHash)) {
+            return blockTag;
+        }
+        return super.blockTag(blockTag);
+    }
+}
+
+exports.FormatterWithEIP1898 = FormatterWithEIP1898;

package/dist/execution.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { ExecutionModuleAsyncOptions, ExecutionModuleSyncOptions } from './interfaces/module.options';
+export declare class ExecutionModule {
+    static forRoot(options: ExecutionModuleSyncOptions): DynamicModule;
+    static forFeature(options: ExecutionModuleSyncOptions): DynamicModule;
+    static forRootAsync(options: ExecutionModuleAsyncOptions): DynamicModule;
+    static forFeatureAsync(options: ExecutionModuleAsyncOptions): DynamicModule;
+}

package/dist/execution.module.js

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var common = require('@nestjs/common');
+var extendedJsonRpcBatchProvider = require('./provider/extended-json-rpc-batch-provider.js');
+var constants = require('./constants/constants.js');
+var simpleFallbackJsonRpcBatchProvider = require('./provider/simple-fallback-json-rpc-batch-provider.js');
+var logger = require('@lido-nestjs/logger');
+
+var ExecutionModule_1;
+const getModuleProviders = (options) => {
+    return [
+        {
+            provide: simpleFallbackJsonRpcBatchProvider.SimpleFallbackJsonRpcBatchProvider,
+            useFactory: (logger) => {
+                return new simpleFallbackJsonRpcBatchProvider.SimpleFallbackJsonRpcBatchProvider(options, logger);
+            },
+            inject: [logger.LOGGER_PROVIDER],
+        },
+        {
+            provide: extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider,
+            useFactory: () => {
+                return new extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider(options.urls[0], undefined, // options.network,
+                options.requestPolicy, options.fetchMiddlewares);
+            },
+        },
+    ];
+};
+exports.ExecutionModule = ExecutionModule_1 = class ExecutionModule {
+    static forRoot(options) {
+        return Object.assign({ global: true }, this.forFeature(options));
+    }
+    static forFeature(options) {
+        return {
+            module: ExecutionModule_1,
+            imports: options.imports,
+            providers: getModuleProviders(options),
+            exports: [
+                simpleFallbackJsonRpcBatchProvider.SimpleFallbackJsonRpcBatchProvider,
+                extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider,
+            ],
+        };
+    }
+    static forRootAsync(options) {
+        return Object.assign({ global: true }, this.forFeatureAsync(options));
+    }
+    static forFeatureAsync(options) {
+        return {
+            module: ExecutionModule_1,
+            imports: options.imports,
+            providers: [
+                {
+                    provide: constants.EXECUTION_MODULE_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject,
+                },
+                {
+                    provide: simpleFallbackJsonRpcBatchProvider.SimpleFallbackJsonRpcBatchProvider,
+                    useFactory: (logger, options) => {
+                        return new simpleFallbackJsonRpcBatchProvider.SimpleFallbackJsonRpcBatchProvider(options, logger);
+                    },
+                    inject: [logger.LOGGER_PROVIDER, constants.EXECUTION_MODULE_OPTIONS],
+                },
+                {
+                    provide: extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider,
+                    useFactory: (options) => {
+                        return new extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider(options.urls[0], undefined, // options.network,
+                        options.requestPolicy);
+                    },
+                    inject: [constants.EXECUTION_MODULE_OPTIONS],
+                },
+                ...(options.providers || []),
+            ],
+            exports: [
+                simpleFallbackJsonRpcBatchProvider.SimpleFallbackJsonRpcBatchProvider,
+                extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider,
+            ],
+        };
+    }
+};
+exports.ExecutionModule = ExecutionModule_1 = tslib.__decorate([
+    common.Module({})
+], exports.ExecutionModule);

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './provider/extended-json-rpc-batch-provider';
+export * from './provider/simple-fallback-json-rpc-batch-provider';
+export * from './common/queue';
+export * from './execution.module';
+export * from './interfaces/fallback-provider';
+export * from './interfaces/simple-fallback-provider-config';
+export { ExecutionModuleAsyncOptions } from './interfaces/module.options';
+export { ExecutionModuleSyncOptions } from './interfaces/module.options';

package/dist/index.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var extendedJsonRpcBatchProvider = require('./provider/extended-json-rpc-batch-provider.js');
+var simpleFallbackJsonRpcBatchProvider = require('./provider/simple-fallback-json-rpc-batch-provider.js');
+var queue = require('./common/queue.js');
+var execution_module = require('./execution.module.js');
+
+
+
+Object.defineProperty(exports, 'ExtendedJsonRpcBatchProvider', {
+	enumerable: true,
+	get: function () { return extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider; }
+});
+Object.defineProperty(exports, 'SimpleFallbackJsonRpcBatchProvider', {
+	enumerable: true,
+	get: function () { return simpleFallbackJsonRpcBatchProvider.SimpleFallbackJsonRpcBatchProvider; }
+});
+exports.Queue = queue.Queue;
+Object.defineProperty(exports, 'ExecutionModule', {
+	enumerable: true,
+	get: function () { return execution_module.ExecutionModule; }
+});

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

@@ -0,0 +1,7 @@
+import { ExtendedJsonRpcBatchProvider } from '../provider/extended-json-rpc-batch-provider';
+import { Network } from '@ethersproject/networks';
+export interface FallbackProvider {
+    provider: ExtendedJsonRpcBatchProvider;
+    network: Network | null;
+    index: number;
+}

package/dist/interfaces/module.options.d.ts

@@ -0,0 +1,8 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { SimpleFallbackProviderConfig } from './simple-fallback-provider-config';
+export interface ExecutionModuleSyncOptions extends Pick<ModuleMetadata, 'imports'>, SimpleFallbackProviderConfig {
+}
+export interface ExecutionModuleAsyncOptions extends Pick<ModuleMetadata, 'imports' | 'providers'> {
+    useFactory: (...args: any[]) => Promise<ExecutionModuleSyncOptions> | ExecutionModuleSyncOptions;
+    inject: any[];
+}

package/dist/interfaces/networkish.d.ts

@@ -0,0 +1,7 @@
+export declare type ChainId = number;
+export declare type NetworkInfo = {
+    name: string;
+    chainId: ChainId;
+    ensAddress?: string;
+};
+export declare type Networkish = NetworkInfo | ChainId;

package/dist/interfaces/non-empty-array.d.ts

@@ -0,0 +1,3 @@
+export declare type NonEmptyArray<T> = T[] & {
+    0: T;
+};

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

@@ -0,0 +1,15 @@
+import { RequestPolicy } from '../provider/extended-json-rpc-batch-provider';
+import { ConnectionInfo } from '@ethersproject/web';
+import { Networkish } from './networkish';
+import { NonEmptyArray } from './non-empty-array';
+import { MiddlewareCallback } from '@lido-nestjs/middleware';
+export interface SimpleFallbackProviderConfig {
+    urls: NonEmptyArray<ConnectionInfo | string>;
+    network: Networkish;
+    requestPolicy?: RequestPolicy;
+    maxRetries?: number;
+    minBackoffMs?: number;
+    maxBackoffMs?: number;
+    logRetries?: boolean;
+    fetchMiddlewares?: MiddlewareCallback<Promise<any>>[];
+}

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

@@ -0,0 +1,77 @@
+/// <reference types="node" />
+import { Deferrable } from '@ethersproject/properties';
+import { ConnectionInfo, FetchJsonResponse } from '@ethersproject/web';
+import { Formatter, JsonRpcProvider } from '@ethersproject/providers';
+import { Network, Networkish } from '@ethersproject/networks';
+import { Queue } from '../common/queue';
+import { LimitFunction } from '../common/promise-limit';
+import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
+import { BlockTag } from '../ethers/block-tag';
+import { TransactionRequest } from '@ethersproject/abstract-provider/src.ts/index';
+import { MiddlewareCallback, MiddlewareService } from '@lido-nestjs/middleware';
+export interface RequestPolicy {
+    jsonRpcMaxBatchSize: number;
+    maxConcurrentRequests: number;
+    batchAggregationWaitMs: number;
+}
+export interface JsonRpcRequest {
+    method: string;
+    params: Array<unknown>;
+    id: number;
+    jsonrpc: '2.0';
+}
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export interface FullRequestIntent {
+    request: JsonRpcRequest;
+    resolve: (result: unknown) => void;
+    reject: (error: Error) => void;
+}
+export interface RequestIntent {
+    request: FullRequestIntent['request'];
+    resolve: FullRequestIntent['resolve'] | null;
+    reject: FullRequestIntent['reject'] | null;
+}
+export declare type PartialRequestIntent = RequestIntent | {
+    request: RequestIntent['request'];
+    resolve: null;
+    reject: null;
+};
+/**
+ * EIP-1898 support
+ * https://eips.ethereum.org/EIPS/eip-1898
+ */
+declare module '@ethersproject/providers' {
+    interface JsonRpcProvider {
+        getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
+        getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
+        getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+        getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+        call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    }
+}
+export declare class ExtendedJsonRpcBatchProvider extends JsonRpcProvider {
+    protected _batchAggregator: NodeJS.Timer | null;
+    protected _queue: Queue<FullRequestIntent>;
+    protected _requestPolicy: RequestPolicy;
+    protected _concurrencyLimiter: LimitFunction;
+    protected _tickCounter: number;
+    protected _fetchMiddlewareService: MiddlewareService<Promise<any>>;
+    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;
+    use(callback: MiddlewareCallback<Promise<any>>): void;
+    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

@@ -0,0 +1,149 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var properties = require('@ethersproject/properties');
+var web = require('@ethersproject/web');
+var providers = require('@ethersproject/providers');
+var queue = require('../common/queue.js');
+var fetch_error = require('../error/fetch.error.js');
+var common = require('@nestjs/common');
+var promiseLimit = require('../common/promise-limit.js');
+var formatterWithEip1898 = require('../ethers/formatter-with-eip1898.js');
+var middleware = require('@lido-nestjs/middleware');
+
+exports.ExtendedJsonRpcBatchProvider = class ExtendedJsonRpcBatchProvider extends providers.JsonRpcProvider {
+    constructor(url, network, requestPolicy, fetchMiddlewares = []) {
+        super(url, network);
+        this._batchAggregator = null;
+        this._queue = new queue.Queue();
+        this._tickCounter = 0;
+        this._requestPolicy = requestPolicy !== null && requestPolicy !== void 0 ? requestPolicy : {
+            jsonRpcMaxBatchSize: 200,
+            maxConcurrentRequests: 5,
+            batchAggregationWaitMs: 10,
+        };
+        this._concurrencyLimiter = promiseLimit["default"](this._requestPolicy.maxConcurrentRequests);
+        this._fetchMiddlewareService = new middleware.MiddlewareService({
+            middlewares: fetchMiddlewares,
+        });
+    }
+    static getFormatter() {
+        if (this._formatter == null) {
+            this._formatter = new formatterWithEip1898.FormatterWithEIP1898();
+        }
+        return this._formatter;
+    }
+    _batchAggregatorTick() {
+        this._tickCounter++;
+        if (this._queue.length > this._requestPolicy.jsonRpcMaxBatchSize ||
+            this._tickCounter > 2) {
+            this._tickCounter = 0;
+            // getting multiple ('jsonRpcMaxBatchSize') elements from queue at once
+            // 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',
+                request: properties.deepCopy(batchRequest),
+                provider: this,
+            });
+            this._concurrencyLimiter(() => {
+                return this._fetchMiddlewareService.go(() => this.fetchJson(this.connection, JSON.stringify(batchRequest)));
+            }).then((batchResult) => {
+                this.emit('debug', {
+                    action: 'response',
+                    request: properties.deepCopy(batchRequest),
+                    response: properties.deepCopy(batchResult),
+                    provider: this,
+                });
+                const resultMap = batchResult.reduce((resultMap, payload) => {
+                    resultMap[payload.id] = payload;
+                    return resultMap;
+                }, {});
+                // For each batch, feed it to the correct Promise, depending
+                // on whether it was a success or error
+                batch.forEach((inflightRequest) => {
+                    const payload = resultMap[inflightRequest.request.id];
+                    if (payload.error) {
+                        const error = new fetch_error.FetchError(payload.error.message);
+                        error.code = payload.error.code;
+                        error.data = payload.error.data;
+                        inflightRequest.reject(error);
+                    }
+                    else {
+                        inflightRequest.resolve(payload.result);
+                    }
+                });
+            }, (error) => {
+                this.emit('debug', {
+                    action: 'response',
+                    error: error,
+                    request: properties.deepCopy(batchRequest),
+                    provider: this,
+                });
+                batch.forEach((inflightRequest) => {
+                    inflightRequest.reject(error);
+                });
+            });
+        }
+        this._batchAggregator && clearTimeout(this._batchAggregator);
+        this._batchAggregator = null;
+        // if the queue is not empty we should continue 'ticking'
+        // every 'batchAggregationWaitMs' time, until the queue is empty
+        if (this._queue.length > 0) {
+            this._startBatchAggregator();
+        }
+    }
+    _startBatchAggregator() {
+        if (!this._batchAggregator) {
+            // schedule batch for next event loop + short duration (macrotask)
+            this._batchAggregator = setTimeout(this._batchAggregatorTick.bind(this), this._requestPolicy.batchAggregationWaitMs);
+        }
+    }
+    use(callback) {
+        this._fetchMiddlewareService.use(callback);
+    }
+    send(method, params) {
+        const request = {
+            method: method,
+            params: params,
+            id: this._nextId++,
+            jsonrpc: '2.0',
+        };
+        const currentRequest = {
+            request,
+            reject: null,
+            resolve: null,
+        };
+        const promise = new Promise((resolve, reject) => {
+            currentRequest.resolve = resolve;
+            currentRequest.reject = reject;
+        });
+        this._queue.enqueue(currentRequest);
+        this._startBatchAggregator();
+        return promise;
+    }
+    async detectNetwork() {
+        let network = this.network;
+        if (network == null) {
+            network = await super.detectNetwork();
+            // If still not set, set it
+            if (this._network == null) {
+                // A static network does not support "any"
+                properties.defineReadOnly(this, '_network', network);
+                this.emit('network', network, null);
+            }
+        }
+        return network;
+    }
+    async fetchJson(connection, json, processFunc) {
+        return await web.fetchJson(connection, json, processFunc);
+    }
+};
+exports.ExtendedJsonRpcBatchProvider._formatter = null;
+exports.ExtendedJsonRpcBatchProvider = tslib.__decorate([
+    common.Injectable(),
+    tslib.__metadata("design:paramtypes", [Object, Object, Object, Array])
+], exports.ExtendedJsonRpcBatchProvider);

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

@@ -0,0 +1,39 @@
+import { BaseProvider, Formatter } from '@ethersproject/providers';
+import { SimpleFallbackProviderConfig } from '../interfaces/simple-fallback-provider-config';
+import { Network } from '@ethersproject/networks';
+import { LoggerService } from '@nestjs/common';
+import { FallbackProvider } from '../interfaces/fallback-provider';
+import { BlockTag } from '../ethers/block-tag';
+import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
+import { Deferrable } from '@ethersproject/properties';
+import { TransactionRequest } from '@ethersproject/abstract-provider/src.ts/index';
+/**
+ * EIP-1898 support
+ * https://eips.ethereum.org/EIPS/eip-1898
+ */
+declare module '@ethersproject/providers' {
+    interface BaseProvider {
+        getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
+        getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
+        getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+        getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+        call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    }
+}
+export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
+    protected config: SimpleFallbackProviderConfig;
+    protected logger: LoggerService;
+    protected fallbackProviders: [FallbackProvider];
+    protected activeFallbackProviderIndex: number;
+    protected detectNetworkFirstRun: boolean;
+    constructor(config: SimpleFallbackProviderConfig, logger: LoggerService);
+    static _formatter: Formatter | null;
+    static getFormatter(): Formatter;
+    protected get provider(): FallbackProvider;
+    protected switchToNextProvider(): void;
+    perform(method: string, params: {
+        [name: string]: unknown;
+    }): Promise<unknown>;
+    detectNetwork(): Promise<Network>;
+    protected networksEqual(networkA: Network, networkB: Network): boolean;
+}

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

@@ -0,0 +1,152 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var providers = require('@ethersproject/providers');
+var extendedJsonRpcBatchProvider = require('./extended-json-rpc-batch-provider.js');
+var common = require('@nestjs/common');
+var retrier = require('../common/retrier.js');
+var formatterWithEip1898 = require('../ethers/formatter-with-eip1898.js');
+var networks = require('../common/networks.js');
+
+exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchProvider extends providers.BaseProvider {
+    constructor(config, logger) {
+        super(config.network);
+        this.detectNetworkFirstRun = true;
+        this.config = Object.assign({ maxRetries: 3, minBackoffMs: 500, maxBackoffMs: 5000, logRetries: true }, config);
+        this.logger = logger;
+        const conns = config.urls.filter((url) => {
+            if (!url) {
+                return false;
+            }
+            if (typeof url === 'object' && !url.url) {
+                return false;
+            }
+            return true;
+        });
+        if (conns.length < 1) {
+            throw new Error('No valid URLs or Connections were provided');
+        }
+        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 : []);
+            return {
+                network: null,
+                provider,
+                index,
+            };
+        });
+        this.activeFallbackProviderIndex = 0;
+    }
+    static getFormatter() {
+        if (this._formatter == null) {
+            this._formatter = new formatterWithEip1898.FormatterWithEIP1898();
+        }
+        return this._formatter;
+    }
+    get provider() {
+        if (this.activeFallbackProviderIndex > this.fallbackProviders.length - 1) {
+            this.activeFallbackProviderIndex = 0;
+        }
+        let fallbackProvider = this.fallbackProviders[this.activeFallbackProviderIndex];
+        let attempt = 0;
+        const isValid = (provider) => provider.network !== null &&
+            provider.network.chainId === networks.getNetworkChain(this.config.network);
+        while (!isValid(fallbackProvider) ||
+            attempt < this.fallbackProviders.length) {
+            fallbackProvider =
+                this.fallbackProviders[this.activeFallbackProviderIndex];
+            // skipping providers with unreachable endpoints or networks
+            // that are not equal to predefined network (from config)
+            if (!isValid(fallbackProvider)) {
+                this.activeFallbackProviderIndex++;
+            }
+            attempt++;
+        }
+        return fallbackProvider;
+    }
+    switchToNextProvider() {
+        if (this.fallbackProviders.length === 1) {
+            this.logger.warn('Will not switch to next provider. No valid backup provider provided.');
+            return;
+        }
+        this.activeFallbackProviderIndex++;
+        this.logger.log(`Switched to next provider for execution layer`);
+    }
+    async perform(method, params) {
+        const retry = retrier.retrier(this.logger, this.config.maxRetries, this.config.minBackoffMs, this.config.maxBackoffMs, this.config.logRetries);
+        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
+        while (attempt < this.fallbackProviders.length) {
+            try {
+                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));
+            }
+            catch (e) {
+                this.logger.error('Error while doing ETH1 RPC request. Will try to switch to another provider');
+                this.logger.error(e);
+                this.switchToNextProvider();
+            }
+        }
+        throw new Error('All attempts to do ETH1 RPC request failed');
+    }
+    async detectNetwork() {
+        const results = await Promise.allSettled(this.fallbackProviders.map((c) => c.provider.getNetwork()));
+        results.forEach((result, i) => {
+            if (result.status === 'fulfilled') {
+                this.fallbackProviders[i].network = result.value;
+            }
+            else {
+                this.fallbackProviders[i].network = null;
+            }
+        });
+        let previousNetwork = null;
+        this.fallbackProviders.forEach((fallbackProvider, index) => {
+            if (!fallbackProvider.network) {
+                return;
+            }
+            if (!networks.networksChainsEqual(fallbackProvider.network, this.config.network)) {
+                if (this.detectNetworkFirstRun) {
+                    throw new Error(`Fallback provider [${index}] network chainId ` +
+                        `[${fallbackProvider.network.chainId}] is different to network ` +
+                        `chainId from config [${networks.getNetworkChain(this.config.network)}]`);
+                }
+                // TODO add logs here
+                // skipping network with bad chainId
+                return;
+            }
+            if (previousNetwork) {
+                // Make sure the fallbackProvider network matches the previous network
+                if (!this.networksEqual(previousNetwork, fallbackProvider.network)) {
+                    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`);
+                }
+            }
+            else {
+                previousNetwork = fallbackProvider.network;
+            }
+        });
+        if (!previousNetwork) {
+            throw new Error('All fallback endpoints are unreachable or all fallback networks differ between each other');
+        }
+        if (this.detectNetworkFirstRun) {
+            this.detectNetworkFirstRun = false;
+        }
+        return previousNetwork;
+    }
+    networksEqual(networkA, networkB) {
+        return networks.networksEqual(networkA, networkB);
+    }
+};
+exports.SimpleFallbackJsonRpcBatchProvider._formatter = null;
+exports.SimpleFallbackJsonRpcBatchProvider = tslib.__decorate([
+    common.Injectable(),
+    tslib.__metadata("design:paramtypes", [Object, Object])
+], exports.SimpleFallbackJsonRpcBatchProvider);

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@lido-nestjs/execution",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "homepage": "https://github.com/lidofinance/lido-nestjs-modules",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lidofinance/lido-nestjs-modules.git",
+    "directory": "packages/execution"
+  },
+  "bugs": {
+    "url": "https://github.com/lidofinance/lido-nestjs-modules/issues"
+  },
+  "sideEffects": false,
+  "keywords": [
+    "lido",
+    "lido-nestjs",
+    "lido-nestjs-modules",
+    "lidofinance",
+    "execution",
+    "execution-layer",
+    "provider"
+  ],
+  "files": [
+    "dist/*"
+  ],
+  "scripts": {
+    "lint": "eslint --ext ts ."
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {
+    "@ethersproject/networks": "^5.5.2",
+    "@ethersproject/properties": "^5.5.0",
+    "@ethersproject/providers": "^5.5.3",
+    "@ethersproject/web": "^5.5.1",
+    "@lido-nestjs/logger": "1.0.3",
+    "@lido-nestjs/middleware": "1.1.1"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^8.2.5",
+    "@nestjs/core": "^8.2.5",
+    "reflect-metadata": "^0.1.13",
+    "rxjs": "^7.5.2",
+    "tslib": "^2.3.1"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^8.2.5",
+    "@nestjs/core": "^8.2.5",
+    "@nestjs/testing": "^8.2.5",
+    "reflect-metadata": "^0.1.13",
+    "rxjs": "^7.5.2"
+  }
+}