@lido-nestjs/execution 1.1.0 → 1.4.0

package/README.md

@@ -16,13 +16,13 @@ yarn add @lido-nestjs/execution
 ```ts
 // Import
 import { Injectable, Module } from '@nestjs/common';
-import { ExecutionModule } from '@lido-nestjs/execution';
+import { FallbackProviderModule } from '@lido-nestjs/execution';
 import { MyService } from './my.service';
 
 @Module({
   imports: [
     LoggerModule.forRoot({}),
-    ExecutionModule.forRoot({
+    FallbackProviderModule.forRoot({
       imports: [],
       urls: ['http://localhost:8545', 'http://fallback:8545'],
       network: 1,
@@ -48,4 +48,25 @@ export class MyService {
 
 ### Async usage
 
-// TODO
+```ts
+import { Module } from '@nestjs/common';
+import { FallbackProviderModule } from '@lido-nestjs/execution';
+import { ConfigModule, ConfigService } from './my.service';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot(),
+    FetchModule.forRoot(),
+    FallbackProviderModule.forRootAsync({
+      async useFactory(configService: ConfigService) {
+        return {
+          urls: configService.urls,
+          network: configService.network,
+        };
+      },
+      inject: [ConfigService],
+    }),
+  ],
+})
+export class MyModule {}
+```

package/dist/batch-provider.module.d.ts

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

package/dist/batch-provider.module.js

@@ -0,0 +1,61 @@
+'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 BatchProviderModule_1;
+const getModuleProviders = (options) => {
+    return [
+        {
+            provide: extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider,
+            useFactory: () => {
+                return new extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider(options.url, options.network, options.requestPolicy, options.fetchMiddlewares);
+            },
+        },
+    ];
+};
+exports.BatchProviderModule = BatchProviderModule_1 = class BatchProviderModule {
+    static forRoot(options) {
+        return Object.assign({ global: true }, this.forFeature(options));
+    }
+    static forFeature(options) {
+        return {
+            module: BatchProviderModule_1,
+            imports: options.imports,
+            providers: getModuleProviders(options),
+            exports: [extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider],
+        };
+    }
+    static forRootAsync(options) {
+        return Object.assign({ global: true }, this.forFeatureAsync(options));
+    }
+    static forFeatureAsync(options) {
+        return {
+            module: BatchProviderModule_1,
+            imports: options.imports,
+            providers: [
+                {
+                    provide: constants.BATCH_PROVIDER_MODULE_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject,
+                },
+                {
+                    provide: extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider,
+                    useFactory: (options) => {
+                        return new extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider(options.url, options.network, options.requestPolicy, options.fetchMiddlewares);
+                    },
+                    inject: [constants.BATCH_PROVIDER_MODULE_OPTIONS],
+                },
+                ...(options.providers || []),
+            ],
+            exports: [extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider],
+        };
+    }
+};
+exports.BatchProviderModule = BatchProviderModule_1 = tslib.__decorate([
+    common.Module({})
+], exports.BatchProviderModule);

package/dist/constants/constants.d.ts

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

package/dist/constants/constants.js

@@ -2,16 +2,8 @@
 
 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];
+const FALLBACK_PROVIDER_MODULE_OPTIONS = Symbol('fallback-provider-module-options');
+const BATCH_PROVIDER_MODULE_OPTIONS = Symbol('batch-provider-module-options');
 
-exports.EXECUTION_MODULE_OPTIONS = EXECUTION_MODULE_OPTIONS;
+exports.BATCH_PROVIDER_MODULE_OPTIONS = BATCH_PROVIDER_MODULE_OPTIONS;
+exports.FALLBACK_PROVIDER_MODULE_OPTIONS = FALLBACK_PROVIDER_MODULE_OPTIONS;

package/dist/error/no-new-blocks-while-polling.error.d.ts

@@ -0,0 +1,6 @@
+export declare class NoNewBlocksWhilePollingError extends Error {
+    name: string;
+    message: string;
+    latestObservedBlockNumber: number;
+    constructor(message: string, latestObservedBlockNumber: number);
+}

package/dist/error/no-new-blocks-while-polling.error.js

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

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

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

package/dist/{execution.module.js → fallback-provider.module.js}

@@ -9,7 +9,7 @@ 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;
+var FallbackProviderModule_1;
 const getModuleProviders = (options) => {
     return [
         {
@@ -28,19 +28,16 @@ const getModuleProviders = (options) => {
         },
     ];
 };
-exports.ExecutionModule = ExecutionModule_1 = class ExecutionModule {
+exports.FallbackProviderModule = FallbackProviderModule_1 = class FallbackProviderModule {
     static forRoot(options) {
         return Object.assign({ global: true }, this.forFeature(options));
     }
     static forFeature(options) {
         return {
-            module: ExecutionModule_1,
+            module: FallbackProviderModule_1,
             imports: options.imports,
             providers: getModuleProviders(options),
-            exports: [
-                simpleFallbackJsonRpcBatchProvider.SimpleFallbackJsonRpcBatchProvider,
-                extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider,
-            ],
+            exports: [simpleFallbackJsonRpcBatchProvider.SimpleFallbackJsonRpcBatchProvider],
         };
     }
     static forRootAsync(options) {
@@ -48,11 +45,11 @@ exports.ExecutionModule = ExecutionModule_1 = class ExecutionModule {
     }
     static forFeatureAsync(options) {
         return {
-            module: ExecutionModule_1,
+            module: FallbackProviderModule_1,
             imports: options.imports,
             providers: [
                 {
-                    provide: constants.EXECUTION_MODULE_OPTIONS,
+                    provide: constants.FALLBACK_PROVIDER_MODULE_OPTIONS,
                     useFactory: options.useFactory,
                     inject: options.inject,
                 },
@@ -61,25 +58,14 @@ exports.ExecutionModule = ExecutionModule_1 = class ExecutionModule {
                     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],
+                    inject: [logger.LOGGER_PROVIDER, constants.FALLBACK_PROVIDER_MODULE_OPTIONS],
                 },
                 ...(options.providers || []),
             ],
-            exports: [
-                simpleFallbackJsonRpcBatchProvider.SimpleFallbackJsonRpcBatchProvider,
-                extendedJsonRpcBatchProvider.ExtendedJsonRpcBatchProvider,
-            ],
+            exports: [simpleFallbackJsonRpcBatchProvider.SimpleFallbackJsonRpcBatchProvider],
         };
     }
 };
-exports.ExecutionModule = ExecutionModule_1 = tslib.__decorate([
+exports.FallbackProviderModule = FallbackProviderModule_1 = tslib.__decorate([
     common.Module({})
-], exports.ExecutionModule);
+], exports.FallbackProviderModule);

package/dist/index.d.ts

@@ -1,8 +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 './fallback-provider.module';
+export * from './batch-provider.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';
+export * from './interfaces/module.options';

package/dist/index.js

@@ -5,7 +5,8 @@ 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');
+var fallbackProvider_module = require('./fallback-provider.module.js');
+var batchProvider_module = require('./batch-provider.module.js');
 
 
 
@@ -18,7 +19,11 @@ Object.defineProperty(exports, 'SimpleFallbackJsonRpcBatchProvider', {
 	get: function () { return simpleFallbackJsonRpcBatchProvider.SimpleFallbackJsonRpcBatchProvider; }
 });
 exports.Queue = queue.Queue;
-Object.defineProperty(exports, 'ExecutionModule', {
+Object.defineProperty(exports, 'FallbackProviderModule', {
 	enumerable: true,
-	get: function () { return execution_module.ExecutionModule; }
+	get: function () { return fallbackProvider_module.FallbackProviderModule; }
+});
+Object.defineProperty(exports, 'BatchProviderModule', {
+	enumerable: true,
+	get: function () { return batchProvider_module.BatchProviderModule; }
 });

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

@@ -4,4 +4,5 @@ export interface FallbackProvider {
     provider: ExtendedJsonRpcBatchProvider;
     network: Network | null;
     index: number;
+    unreachable: boolean;
 }

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

@@ -1,8 +1,22 @@
 import { ModuleMetadata } from '@nestjs/common';
 import { SimpleFallbackProviderConfig } from './simple-fallback-provider-config';
-export interface ExecutionModuleSyncOptions extends Pick<ModuleMetadata, 'imports'>, SimpleFallbackProviderConfig {
+import { ConnectionInfo } from '@ethersproject/web';
+import { Networkish } from './networkish';
+import { RequestPolicy } from '../provider/extended-json-rpc-batch-provider';
+import { MiddlewareCallback } from '@lido-nestjs/middleware';
+export interface FallbackProviderModuleSyncOptions extends Pick<ModuleMetadata, 'imports'>, SimpleFallbackProviderConfig {
 }
-export interface ExecutionModuleAsyncOptions extends Pick<ModuleMetadata, 'imports' | 'providers'> {
-    useFactory: (...args: any[]) => Promise<ExecutionModuleSyncOptions> | ExecutionModuleSyncOptions;
+export interface BatchProviderModuleSyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    url: ConnectionInfo | string;
+    network?: Networkish;
+    requestPolicy?: RequestPolicy;
+    fetchMiddlewares?: MiddlewareCallback<Promise<any>>[];
+}
+export interface FallbackProviderModuleAsyncOptions extends Pick<ModuleMetadata, 'imports' | 'providers'> {
+    useFactory: (...args: any[]) => Promise<FallbackProviderModuleSyncOptions> | FallbackProviderModuleSyncOptions;
+    inject: any[];
+}
+export interface BatchProviderModuleAsyncOptions extends Pick<ModuleMetadata, 'imports' | 'providers'> {
+    useFactory: (...args: any[]) => Promise<BatchProviderModuleSyncOptions> | BatchProviderModuleSyncOptions;
     inject: any[];
 }

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

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

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

@@ -7,6 +7,7 @@ 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';
+import { EventType, Listener } from '@ethersproject/abstract-provider';
 /**
  * EIP-1898 support
  * https://eips.ethereum.org/EIPS/eip-1898
@@ -26,14 +27,17 @@ export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
     protected fallbackProviders: [FallbackProvider];
     protected activeFallbackProviderIndex: number;
     protected detectNetworkFirstRun: boolean;
+    protected resetTimer: ReturnType<typeof setTimeout> | null;
     constructor(config: SimpleFallbackProviderConfig, logger: LoggerService);
     static _formatter: Formatter | null;
     static getFormatter(): Formatter;
+    on(eventName: EventType, listener: Listener): this;
     protected get provider(): FallbackProvider;
     protected switchToNextProvider(): void;
     perform(method: string, params: {
         [name: string]: unknown;
     }): Promise<unknown>;
     detectNetwork(): Promise<Network>;
+    protected resetFallbacks(): void;
     protected networksEqual(networkA: Network, networkB: Network): boolean;
 }

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

@@ -9,12 +9,14 @@ 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');
+var noNewBlocksWhilePolling_error = require('../error/no-new-blocks-while-polling.error.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.resetTimer = null;
+        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) => {
             if (!url) {
@@ -35,6 +37,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                 network: null,
                 provider,
                 index,
+                unreachable: false,
             };
         });
         this.activeFallbackProviderIndex = 0;
@@ -45,6 +48,25 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         }
         return this._formatter;
     }
+    on(eventName, listener) {
+        let dieTimer = null;
+        const startDieTimer = (latestObservedBlockNumber) => {
+            if (dieTimer)
+                clearTimeout(dieTimer);
+            dieTimer = setTimeout(async () => {
+                const error = new noNewBlocksWhilePolling_error.NoNewBlocksWhilePollingError('No new blocks for a long time while polling', latestObservedBlockNumber);
+                this.emit('error', error);
+            }, this.config.maxTimeWithoutNewBlocksMs);
+        };
+        if (eventName === 'block') {
+            startDieTimer(-1);
+            super.on(eventName, function (...args) {
+                startDieTimer(args[0]);
+                return listener.apply(this, args);
+            });
+        }
+        return super.on(eventName, listener);
+    }
     get provider() {
         if (this.activeFallbackProviderIndex > this.fallbackProviders.length - 1) {
             this.activeFallbackProviderIndex = 0;
@@ -53,7 +75,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         let attempt = 0;
         const isValid = (provider) => provider.network !== null &&
             provider.network.chainId === networks.getNetworkChain(this.config.network);
-        while (!isValid(fallbackProvider) ||
+        while (!isValid(fallbackProvider) &&
             attempt < this.fallbackProviders.length) {
             fallbackProvider =
                 this.fallbackProviders[this.activeFallbackProviderIndex];
@@ -96,13 +118,17 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         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) => {
+        const results = await Promise.allSettled(this.fallbackProviders
+            .filter((c) => !c.unreachable)
+            .map((c) => c.provider.getNetwork()));
+        results.forEach((result, index) => {
             if (result.status === 'fulfilled') {
-                this.fallbackProviders[i].network = result.value;
+                this.fallbackProviders[index].network = result.value;
+                this.fallbackProviders[index].unreachable = false;
             }
             else {
-                this.fallbackProviders[i].network = null;
+                this.fallbackProviders[index].network = null;
+                this.fallbackProviders[index].unreachable = true;
             }
         });
         let previousNetwork = null;
@@ -139,8 +165,26 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         if (this.detectNetworkFirstRun) {
             this.detectNetworkFirstRun = false;
         }
+        if (this.resetTimer) {
+            clearTimeout(this.resetTimer);
+        }
+        this.resetTimer = setTimeout(() => {
+            this.resetFallbacks();
+        }, this.config.resetIntervalMs || 10000);
         return previousNetwork;
     }
+    resetFallbacks() {
+        if (this.resetTimer) {
+            clearTimeout(this.resetTimer);
+        }
+        this.fallbackProviders.forEach((fallbackProvider, index) => {
+            var _a;
+            if (!((_a = this.fallbackProviders[index].network) === null || _a === void 0 ? void 0 : _a.chainId)) {
+                this.fallbackProviders[index].unreachable = false;
+            }
+        });
+        this.activeFallbackProviderIndex = 0;
+    }
     networksEqual(networkA, networkB) {
         return networks.networksEqual(networkA, networkB);
     }

package/package.json

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

package/dist/execution.module.d.ts

@@ -1,8 +0,0 @@
-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;
-}