@quantform/core 0.3.243 → 0.3.251

package/src/adapter/adapter-aggregate.ts

@@ -4,8 +4,15 @@ import { Logger } from '../shared';
 import {
   AdapterAccountCommand,
   AdapterAwakeCommand,
-  AdapterDisposeCommand
+  AdapterDisposeCommand,
+  AdapterFeedCommand,
+  AdapterHistoryQuery,
+  AdapterOrderCancelCommand,
+  AdapterOrderOpenCommand,
+  AdapterSubscribeCommand
 } from './adapter.event';
+import { InstrumentSelector, Order, Candle } from '../domain';
+import { Feed } from './../storage';
 
 /**
  * Manages instances of all adapters provided in session descriptor.
@@ -14,21 +21,26 @@ import {
 export class AdapterAggregate {
   private readonly adapter: Record<string, Adapter> = {};
 
-  constructor(private readonly store: Store, adapters: Adapter[]) {
+  constructor(adapters: Adapter[], private readonly store: Store) {
     adapters.forEach(it => (this.adapter[it.name] = it));
   }
 
+  /**
+   * Returns adapter by name.
+   * @param adapterName adapter name.
+   * @returns
+   */
+  get(adapterName: string): Adapter {
+    return this.adapter[adapterName];
+  }
+
   /**
    * Sets up all adapters.
-   * @param usePrivateScope use private api (api keys needed).
    */
-  async awake(usePrivateScope = true): Promise<void> {
+  async awake(): Promise<void> {
     for (const adapter in this.adapter) {
       await this.dispatch(adapter, new AdapterAwakeCommand());
-
-      if (usePrivateScope) {
-        await this.dispatch(adapter, new AdapterAccountCommand());
-      }
+      await this.dispatch(adapter, new AdapterAccountCommand());
     }
   }
 
@@ -41,17 +53,102 @@ export class AdapterAggregate {
     }
   }
 
+  /**
+   * Subscribe to collection of instruments.
+   * @param selectors
+   */
+  async subscribe(selectors: InstrumentSelector[]): Promise<void> {
+    const grouped = selectors
+      .filter(it => it != null)
+      .reduce((aggregate, it) => {
+        const adapter = it.base.adapter;
+
+        if (aggregate[adapter]) {
+          aggregate[adapter].push(it);
+        } else {
+          aggregate[adapter] = [it];
+        }
+
+        return aggregate;
+      }, {});
+
+    for (const adapterName in grouped) {
+      await this.dispatch(adapterName, new AdapterSubscribeCommand(grouped[adapterName]));
+    }
+  }
+
+  /**
+   * Opens new order.
+   * @param order an order to open.
+   */
+  open(order: Order): Promise<void> {
+    return this.dispatch<AdapterOrderOpenCommand, void>(
+      order.instrument.base.adapter,
+      new AdapterOrderOpenCommand(order)
+    );
+  }
+
+  /**
+   * Cancels specific order.
+   */
+  cancel(order: Order): Promise<void> {
+    return this.dispatch(
+      order.instrument.base.adapter,
+      new AdapterOrderCancelCommand(order)
+    );
+  }
+
+  /**
+   *
+   * @param selector Returns collection of candles for specific history.
+   * @param timeframe
+   * @param length
+   * @returns
+   */
+  history(
+    selector: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]> {
+    return this.dispatch<AdapterHistoryQuery, Candle[]>(
+      selector.base.adapter,
+      new AdapterHistoryQuery(selector, timeframe, length)
+    );
+  }
+
+  /**
+   * Feeds a storage with historical instrument data.
+   * @param selector
+   * @param from
+   * @param to
+   * @param destination
+   * @param callback
+   * @returns
+   */
+  feed(
+    selector: InstrumentSelector,
+    from: number,
+    to: number,
+    destination: Feed,
+    callback: (timestamp: number) => void
+  ): Promise<void> {
+    return this.dispatch(
+      selector.base.adapter,
+      new AdapterFeedCommand(selector, from, to, destination, callback)
+    );
+  }
+
   /**
    * Routes and executes command to a specific adapter.
    * @param adapterName name of adapter
-   * @param event
+   * @param command
    * @returns
    */
-  dispatch<TEvent extends { type: string }, TResponse>(
+  private dispatch<TCommand extends { type: string }, TResponse>(
     adapterName: string,
-    event: TEvent
+    command: TCommand
   ): Promise<TResponse> {
-    const adapter = this.adapter[adapterName];
+    const adapter = this.get(adapterName);
 
     if (!adapter) {
       throw new Error(
@@ -60,7 +157,7 @@ export class AdapterAggregate {
     }
 
     try {
-      return adapter.dispatch(event, new AdapterContext(adapter, this.store));
+      return adapter.dispatch(command, new AdapterContext(adapter, this.store));
     } catch (e) {
       Logger.error(e);
     }

package/src/adapter/backtester/backtester-adapter.ts

@@ -1,15 +1,14 @@
 import { Adapter, AdapterContext } from '..';
-import { BacktesterListener, BacktesterStreamer } from './backtester-streamer';
+import { BacktesterStreamer } from './backtester-streamer';
 import { PaperAdapter, PaperOptions } from '../paper';
 import { handler } from '../../shared/topic';
-import { Logger, timestamp } from '../../shared';
+import { timestamp } from '../../shared';
 import { AdapterSubscribeCommand, AdapterHistoryQuery } from '../adapter.event';
 import { InstrumentSubscriptionEvent } from '../../store/event';
 
 export class BacktesterOptions extends PaperOptions {
   from: timestamp;
   to: timestamp;
-  listener?: BacktesterListener;
 }
 
 export class BacktesterAdapter extends Adapter {

package/src/adapter/backtester/backtester-streamer.spec.ts

@@ -18,11 +18,15 @@ describe('backtester streamer tests', () => {
     store.snapshot.universe.instrument[instrument.toString()] = instrument;
     store.snapshot.subscription.instrument[instrument.toString()] = instrument;
 
-    const streamer = new BacktesterStreamer(store, feed, {
-      balance: {},
-      from: 0,
-      to: 10,
-      listener: {
+    const streamer = new BacktesterStreamer(
+      store,
+      feed,
+      {
+        balance: {},
+        from: 0,
+        to: 10
+      },
+      {
         onBacktestCompleted: () => {
           const trade = store.snapshot.trade[instrument.toString()];
 
@@ -34,7 +38,7 @@ describe('backtester streamer tests', () => {
           done();
         }
       }
-    });
+    );
 
     feed
       .save(instrument, [

package/src/adapter/backtester/backtester-streamer.ts

@@ -36,7 +36,8 @@ export class BacktesterStreamer {
   constructor(
     private readonly store: Store,
     private readonly feed: Feed,
-    private readonly options: BacktesterOptions
+    private readonly options: BacktesterOptions,
+    private readonly listener?: BacktesterListener
   ) {
     this.timestamp = this.options.from;
   }
@@ -73,15 +74,15 @@ export class BacktesterStreamer {
     }
 
     if (this.sequence == 0) {
-      if (this.options.listener.onBacktestStarted) {
-        this.options.listener.onBacktestStarted(this);
+      if (this.listener.onBacktestStarted) {
+        this.listener.onBacktestStarted(this);
       }
     }
 
     while (await this.processNext()) {
       if (this.sequence % this.sequenceUpdateBatch == 0) {
-        if (this.options.listener.onBacktestUpdated) {
-          this.options.listener.onBacktestUpdated(this);
+        if (this.listener.onBacktestUpdated) {
+          this.listener.onBacktestUpdated(this);
         }
       }
 
@@ -90,8 +91,8 @@ export class BacktesterStreamer {
       }
     }
 
-    if (this.options.listener.onBacktestCompleted) {
-      this.options.listener.onBacktestCompleted(this);
+    if (this.listener.onBacktestCompleted) {
+      this.listener.onBacktestCompleted(this);
     }
   }
 

package/src/bin.ts

@@ -1,10 +1,10 @@
 import {
   BacktesterAdapter,
-  BacktesterOptions,
+  BacktesterListener,
   BacktesterStreamer
 } from './adapter/backtester';
 import { AdapterAggregate } from './adapter';
-import { PaperAdapter, PaperOptions } from './adapter/paper';
+import { PaperAdapter } from './adapter/paper';
 import { Session, SessionDescriptor } from './session';
 import { Store } from './store';
 
@@ -16,16 +16,26 @@ import { Store } from './store';
  */
 export function backtest(
   descriptor: SessionDescriptor,
-  options: BacktesterOptions
+  listener?: BacktesterListener
 ): [Session, BacktesterStreamer] {
   const store = new Store();
 
-  const streamer = new BacktesterStreamer(store, descriptor.feed, options);
-  const aggregate = new AdapterAggregate(
+  const streamer = new BacktesterStreamer(
     store,
+    descriptor.feed,
+    descriptor.options.backtester,
+    listener
+  );
+  const aggregate = new AdapterAggregate(
     descriptor.adapter.map(
-      it => new PaperAdapter(new BacktesterAdapter(it, streamer), store, options)
-    )
+      it =>
+        new PaperAdapter(
+          new BacktesterAdapter(it, streamer),
+          store,
+          descriptor.options.backtester
+        )
+    ),
+    store
   );
 
   return [new Session(store, aggregate, descriptor), streamer];
@@ -37,12 +47,12 @@ export function backtest(
  * @param options backtest options.
  * @returns new session object.
  */
-export function paper(descriptor: SessionDescriptor, options: PaperOptions): Session {
+export function paper(descriptor: SessionDescriptor): Session {
   const store = new Store();
 
   const aggregate = new AdapterAggregate(
-    store,
-    descriptor.adapter.map(it => new PaperAdapter(it, store, options))
+    descriptor.adapter.map(it => new PaperAdapter(it, store, descriptor.options.paper)),
+    store
   );
 
   return new Session(store, aggregate, descriptor);
@@ -55,7 +65,7 @@ export function paper(descriptor: SessionDescriptor, options: PaperOptions): Ses
  */
 export function live(descriptor: SessionDescriptor): Session {
   const store = new Store();
-  const aggregate = new AdapterAggregate(store, descriptor.adapter);
+  const aggregate = new AdapterAggregate(descriptor.adapter, store);
 
   return new Session(store, aggregate, descriptor);
 }

package/src/ipc.spec.ts

@@ -55,8 +55,7 @@ describe('ipc feed tests', () => {
     const session = await run(
       {
         adapter: [new DefaultAdapter()],
-        feed: new Feed(new InMemoryStorage()),
-        describe: (session: Session) => session.trade(instrumentOf('default:btc-usdt'))
+        feed: new Feed(new InMemoryStorage())
       },
       command
     );
@@ -66,8 +65,7 @@ describe('ipc feed tests', () => {
 
   test('should dispatch session started event', done => {
     const command = {
-      type: 'paper',
-      balance: { 'default:usd': 100 }
+      type: 'paper'
     };
 
     const ipcSub = new EventEmitter();
@@ -80,8 +78,12 @@ describe('ipc feed tests', () => {
     run(
       {
         adapter: [new DefaultAdapter()],
-        describe: (session: Session) => session.trade(instrumentOf('default:btc-usdt')),
-        ipcSub
+        ipcSub,
+        options: {
+          paper: {
+            balance: { 'default:usd': 100 }
+          }
+        }
       },
       command
     );
@@ -102,8 +104,7 @@ describe('ipc feed tests', () => {
 
     run(
       {
-        adapter: [new DefaultAdapter()],
-        describe: (session: Session) => session.trade(instrumentOf('default:btc-usdt'))
+        adapter: [new DefaultAdapter()]
       },
       command
     );

package/src/ipc.ts

@@ -1,11 +1,12 @@
-import { AdapterFeedCommand } from './adapter';
 import { Session, SessionDescriptor } from './session';
 import { instrumentOf } from './domain';
 import { Topic, event, handler } from './shared/topic';
 import { runTask, Logger } from './shared';
 import { backtest, live, paper } from './bin';
 import { BacktesterStreamer } from './adapter/backtester';
+import { Observable } from 'rxjs';
 import { EventEmitter } from 'events';
+import { join } from 'path';
 import minimist = require('minimist');
 import dotenv = require('dotenv');
 
@@ -46,12 +47,6 @@ export class IpcPaperCommand implements IpcCommand {
    * The optional session identifier.
    */
   id?: number;
-
-  /**
-   * Specifies trading balance, for example:
-   * { "binance:usdt": 1000 }
-   */
-  balance: { [key: string]: number };
 }
 
 /**
@@ -62,20 +57,14 @@ export class IpcBacktestCommand implements IpcCommand {
   type = 'backtest';
 
   /**
-   * Start date of the backtest in unix timestamp.
-   */
-  from: number;
-
-  /**
-   * Due date of the backtest in unix timestamp.
+   * Start date of the feed in unix timestamp.
    */
-  to: number;
+  from?: number;
 
   /**
-   * Specifies trading balance, for example:
-   * { "binance:usdt": 1000 }
+   * Due date of the feed in unix timestamp.
    */
-  balance: { [key: string]: number };
+  to?: number;
 }
 
 /**
@@ -93,12 +82,12 @@ export class IpcFeedCommand implements IpcCommand {
   /**
    * Start date of the feed in unix timestamp.
    */
-  from: number;
+  from?: number;
 
   /**
    * Due date of the feed in unix timestamp.
    */
-  to: number;
+  to?: number;
 }
 
 /**
@@ -121,13 +110,13 @@ class IpcSessionAccessor {
   session: Session;
 }
 
-export declare type SessionRunDescriptor = SessionDescriptor & { ipcSub?: EventEmitter };
+export declare type IpcSessionDescriptor = SessionDescriptor & { ipcSub?: EventEmitter };
 
 /**
  * Inter process communication handler.
  */
 class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
-  constructor(private readonly descriptor: SessionRunDescriptor) {
+  constructor(private readonly descriptor: IpcSessionDescriptor) {
     super();
   }
 
@@ -142,12 +131,12 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
 
     accessor.session = live(this.descriptor);
 
-    this.notify({
+    this.emit({
       type: 'live:started',
       session: accessor.session.descriptor?.id
     });
 
-    await accessor.session.awake();
+    await accessor.session.awake(this.describe());
   }
 
   /**
@@ -159,16 +148,14 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
       this.descriptor.id = command.id;
     }
 
-    accessor.session = paper(this.descriptor, {
-      balance: command.balance
-    });
+    accessor.session = paper(this.descriptor);
 
-    this.notify({
+    this.emit({
       type: 'paper:started',
       session: accessor.session.descriptor?.id
     });
 
-    await accessor.session.awake();
+    await accessor.session.awake(this.describe());
   }
 
   /**
@@ -176,49 +163,51 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
    */
   @handler(IpcBacktestCommand)
   onBacktestMode(command: IpcBacktestCommand, accessor: IpcSessionAccessor) {
+    if (command.from) {
+      this.descriptor.options.backtester.from = command.from;
+    }
+    if (command.to) {
+      this.descriptor.options.backtester.to = command.to;
+    }
+
     return new Promise<void>(async resolve => {
       const [session, streamer] = backtest(this.descriptor, {
-        from: command.from,
-        to: command.to,
-        balance: command.balance,
-        listener: {
-          onBacktestStarted: (streamer: BacktesterStreamer) => {
-            this.notify({
-              type: 'backtest:started',
-              session: session.descriptor?.id,
-              timestamp: streamer.timestamp,
-              from: command.from,
-              to: command.to
-            });
-          },
-          onBacktestUpdated: (streamer: BacktesterStreamer) => {
-            this.notify({
-              type: 'backtest:updated',
-              session: session.descriptor?.id,
-              timestamp: streamer.timestamp,
-              from: command.from,
-              to: command.to
-            });
-          },
-          onBacktestCompleted: async (streamer: BacktesterStreamer) => {
-            await accessor.session.dispose();
-
-            this.notify({
-              type: 'backtest:completed',
-              session: session.descriptor?.id,
-              timestamp: streamer.timestamp,
-              from: command.from,
-              to: command.to
-            });
-
-            resolve();
-          }
+        onBacktestStarted: (streamer: BacktesterStreamer) => {
+          this.emit({
+            type: 'backtest:started',
+            session: session.descriptor?.id,
+            timestamp: streamer.timestamp,
+            from: this.descriptor.options.backtester.from,
+            to: this.descriptor.options.backtester.to
+          });
+        },
+        onBacktestUpdated: (streamer: BacktesterStreamer) => {
+          this.emit({
+            type: 'backtest:updated',
+            session: session.descriptor?.id,
+            timestamp: streamer.timestamp,
+            from: this.descriptor.options.backtester.from,
+            to: this.descriptor.options.backtester.to
+          });
+        },
+        onBacktestCompleted: async (streamer: BacktesterStreamer) => {
+          await accessor.session.dispose();
+
+          this.emit({
+            type: 'backtest:completed',
+            session: session.descriptor?.id,
+            timestamp: streamer.timestamp,
+            from: this.descriptor.options.backtester.from,
+            to: this.descriptor.options.backtester.to
+          });
+
+          resolve();
         }
       });
 
       accessor.session = session;
 
-      await accessor.session.awake();
+      await accessor.session.awake(this.describe());
       await streamer.tryContinue().catch(it => Logger.error(it));
     });
   }
@@ -228,31 +217,38 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
    */
   @handler(IpcFeedCommand)
   async onFeed(command: IpcFeedCommand, accessor: IpcSessionAccessor) {
-    accessor.session = accessor.session ?? live(this.descriptor);
+    if (!this.descriptor.options) {
+      this.descriptor.options = {};
+    }
+
+    if (!this.descriptor.options.paper) {
+      this.descriptor.options.paper = {
+        balance: {}
+      };
+    }
+
+    accessor.session = accessor.session ?? paper(this.descriptor);
     const instrument = instrumentOf(command.instrument);
 
-    await accessor.session.awake(true);
-
-    this.notify({ type: 'feed:started' });
-
-    await accessor.session.aggregate.dispatch(
-      instrument.base.adapter,
-      new AdapterFeedCommand(
-        instrument,
-        command.from,
-        command.to,
-        this.descriptor.feed,
-        timestamp =>
-          this.notify({
-            type: 'feed:updated',
-            timestamp,
-            from: command.from,
-            to: command.to
-          })
-      )
+    await accessor.session.awake(undefined);
+
+    this.emit({ type: 'feed:started' });
+
+    await accessor.session.aggregate.feed(
+      instrument,
+      command.from,
+      command.to,
+      this.descriptor.feed,
+      timestamp =>
+        this.emit({
+          type: 'feed:updated',
+          timestamp,
+          from: command.from,
+          to: command.to
+        })
     );
 
-    this.notify({ type: 'feed:completed' });
+    this.emit({ type: 'feed:completed' });
 
     await accessor.session.dispose();
   }
@@ -264,9 +260,9 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
   async onTask(query: IpcTaskCommand, accessor: IpcSessionAccessor) {
     accessor.session = accessor.session ?? live(this.descriptor);
 
-    await accessor.session.awake(true);
+    await accessor.session.awake(undefined);
 
-    this.notify({ type: 'task:started', taskName: query.taskName });
+    this.emit({ type: 'task:started', taskName: query.taskName });
 
     let result = undefined;
 
@@ -276,15 +272,26 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
       result = e;
     }
 
-    this.notify({ type: 'task:completed', taskName: query.taskName, result });
+    this.emit({ type: 'task:completed', taskName: query.taskName, result });
 
     await accessor.session.dispose();
   }
 
+  describe(): (session: Session) => Observable<any> {
+    const pkg = require(join(process.cwd(), 'package.json'));
+    const describe = require(join(process.cwd(), pkg.main))?.default;
+
+    if (describe instanceof Function) {
+      return describe;
+    }
+
+    return undefined;
+  }
+
   /**
    * Sends a message to parent process.
    */
-  private notify(message: any) {
+  private emit(message: any) {
     if (process.send) {
       process.send(message);
     }
@@ -300,7 +307,7 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
  * @returns new session.
  */
 export async function run(
-  descriptor: SessionRunDescriptor,
+  descriptor: IpcSessionDescriptor,
   ...commands: IpcCommand[]
 ): Promise<Session> {
   const handler = new IpcHandler(descriptor);