@lido-nestjs/execution 1.1.0 → 1.2.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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lido-nestjs/execution",
-  "version": "1.1.0",
+  "version": "1.2.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;
-}