@quantform/core 0.3.239 → 0.3.246

package/src/ipc.ts

@@ -2,13 +2,17 @@ import { AdapterFeedCommand } from './adapter';
 import { Session, SessionDescriptor } from './session';
 import { instrumentOf } from './domain';
 import { Topic, event, handler } from './shared/topic';
-import { Logger } from './shared';
-import { backtest, idle, live, paper } from './bin';
+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');
 
-export const ipcSub = new EventEmitter();
+// force to load environment variables from .env file if this file imported.
+dotenv.config();
 
 /**
  * Base command/query interface for IPC communication.
@@ -44,12 +48,6 @@ export class IpcPaperCommand implements IpcCommand {
    * The optional session identifier.
    */
   id?: number;
-
-  /**
-   * Specifies trading balance, for example:
-   * { "binance:usdt": 1000 }
-   */
-  balance: { [key: string]: number };
 }
 
 /**
@@ -58,28 +56,6 @@ export class IpcPaperCommand implements IpcCommand {
 @event
 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.
-   */
-  to: number;
-
-  /**
-   * Specifies trading balance, for example:
-   * { "binance:usdt": 1000 }
-   */
-  balance: { [key: string]: number };
-}
-
-@event
-export class IpcUniverseQuery implements IpcCommand {
-  type = 'universe';
-  exchange: string;
 }
 
 /**
@@ -97,12 +73,25 @@ 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;
+}
+
+/**
+ * Executes user task defined in quantform.ts file.
+ */
+@event
+export class IpcTaskCommand implements IpcCommand {
+  type = 'task';
+
+  /**
+   * Name of the task to execute.
+   */
+  taskName: string;
 }
 
 /**
@@ -112,11 +101,13 @@ class IpcSessionAccessor {
   session: Session;
 }
 
+export declare type IpcSessionDescriptor = SessionDescriptor & { ipcSub?: EventEmitter };
+
 /**
  * Inter process communication handler.
  */
 class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
-  constructor(private readonly descriptor: SessionDescriptor) {
+  constructor(private readonly descriptor: IpcSessionDescriptor) {
     super();
   }
 
@@ -136,7 +127,7 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
       session: accessor.session.descriptor?.id
     });
 
-    await accessor.session.awake();
+    await accessor.session.awake(this.describe());
   }
 
   /**
@@ -148,16 +139,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({
       type: 'paper:started',
       session: accessor.session.descriptor?.id
     });
 
-    await accessor.session.awake();
+    await accessor.session.awake(this.describe());
   }
 
   /**
@@ -167,73 +156,60 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
   onBacktestMode(command: IpcBacktestCommand, accessor: IpcSessionAccessor) {
     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.notify({
+            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.notify({
+            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.notify({
+            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));
     });
   }
 
-  /**
-   * @see IpcUniverseQuery
-   */
-  @handler(IpcUniverseQuery)
-  onUniverse(query: IpcUniverseQuery, accessor: IpcSessionAccessor) {
-    accessor.session = accessor.session ?? idle(this.descriptor);
-  }
-
   /**
    * @see IpcFeedCommand
    */
   @handler(IpcFeedCommand)
   async onFeed(command: IpcFeedCommand, accessor: IpcSessionAccessor) {
-    accessor.session = accessor.session ?? idle(this.descriptor);
+    accessor.session = accessor.session ?? live(this.descriptor);
     const instrument = instrumentOf(command.instrument);
 
-    await accessor.session.awake();
+    await accessor.session.awake(undefined);
 
     this.notify({ type: 'feed:started' });
 
     await accessor.session.aggregate.dispatch(
-      instrument.base.exchange,
+      instrument.base.adapter,
       new AdapterFeedCommand(
         instrument,
         command.from,
@@ -254,6 +230,41 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
     await accessor.session.dispose();
   }
 
+  /**
+   * @see IpcTaskCommand
+   */
+  @handler(IpcTaskCommand)
+  async onTask(query: IpcTaskCommand, accessor: IpcSessionAccessor) {
+    accessor.session = accessor.session ?? live(this.descriptor);
+
+    await accessor.session.awake(undefined);
+
+    this.notify({ type: 'task:started', taskName: query.taskName });
+
+    let result = undefined;
+
+    try {
+      result = await runTask(query.taskName, accessor.session);
+    } catch (e) {
+      result = e;
+    }
+
+    this.notify({ 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));
+
+    if (describe instanceof Function) {
+      return describe;
+    }
+
+    return undefined;
+  }
+
   /**
    * Sends a message to parent process.
    */
@@ -262,7 +273,7 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
       process.send(message);
     }
 
-    ipcSub.emit('message', message);
+    this.descriptor.ipcSub?.emit('message', message);
   }
 }
 
@@ -273,7 +284,7 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
  * @returns new session.
  */
 export async function run(
-  descriptor: SessionDescriptor,
+  descriptor: IpcSessionDescriptor,
   ...commands: IpcCommand[]
 ): Promise<Session> {
   const handler = new IpcHandler(descriptor);

package/src/session/session-descriptor.ts

@@ -1,8 +1,8 @@
 import { Adapter } from '../adapter';
-import { Session } from '.';
 import { Measurement } from '../storage/measurement';
 import { Feed } from '../storage';
-import { Observable } from 'rxjs';
+import { BacktesterOptions } from './../adapter/backtester';
+import { PaperOptions } from './../adapter/paper';
 
 /**
  * Describes a single session.
@@ -44,7 +44,10 @@ export interface SessionDescriptor {
   measurement?: Measurement;
 
   /**
-   * Describes your trading strategy.
+   * Session additional options.
    */
-  describe?: (session: Session) => Observable<any>;
+  options?: {
+    backtester?: BacktesterOptions;
+    paper?: PaperOptions;
+  };
 }

package/src/session/session.spec.ts

@@ -13,11 +13,7 @@ describe('session tests', () => {
   };
 
   test('should trigger once', done => {
-    const session = paper(descriptor, {
-      balance: {
-        ['binance:btc']: 1.23
-      }
-    });
+    const session = paper(descriptor);
 
     session.instruments().subscribe({
       next: it => {

package/src/session/session.ts

@@ -57,7 +57,7 @@ export class Session {
     }
   }
 
-  async awake(): Promise<void> {
+  async awake(describe: (session: Session) => Observable<any>): Promise<void> {
     if (this.initialized) {
       return;
     }
@@ -67,8 +67,8 @@ export class Session {
     // awake all adapters and synchronize trading accounts with store.
     await this.aggregate.awake(this.descriptor != null);
 
-    if (this.descriptor?.describe) {
-      this.subscription = this.descriptor.describe(this).subscribe();
+    if (describe) {
+      this.subscription = describe(this).subscribe();
     }
   }
 
@@ -151,12 +151,12 @@ export class Session {
     const grouped = instrument
       .filter(it => it != null)
       .reduce((aggregate, it) => {
-        const exchange = it.base.exchange;
+        const adapter = it.base.adapter;
 
-        if (aggregate[exchange]) {
-          aggregate[exchange].push(it);
+        if (aggregate[adapter]) {
+          aggregate[adapter].push(it);
         } else {
-          aggregate[exchange] = [it];
+          aggregate[adapter] = [it];
         }
 
         return aggregate;
@@ -176,7 +176,7 @@ export class Session {
     await Promise.all(
       orders.map(it =>
         this.aggregate.dispatch<AdapterOrderOpenCommand, void>(
-          it.instrument.base.exchange,
+          it.instrument.base.adapter,
           new AdapterOrderOpenCommand(it)
         )
       )
@@ -188,7 +188,7 @@ export class Session {
    */
   cancel(order: Order): Promise<void> {
     return this.aggregate.dispatch(
-      order.instrument.base.exchange,
+      order.instrument.base.adapter,
       new AdapterOrderCancelCommand(order)
     );
   }
@@ -352,7 +352,7 @@ export class Session {
     );
   }
 
-  balance(selector?: AssetSelector): Observable<Balance> {
+  balance(selector: AssetSelector): Observable<Balance> {
     return this.store.changes$.pipe(
       startWith(selector ? this.store.snapshot.balance[selector.toString()] : null),
       filter(
@@ -375,7 +375,7 @@ export class Session {
       switchMap(() =>
         from(
           this.aggregate.dispatch<AdapterHistoryQuery, Candle[]>(
-            selector.base.exchange,
+            selector.base.adapter,
             new AdapterHistoryQuery(selector, timeframe, length)
           )
         )

package/src/shared/index.ts

@@ -5,3 +5,4 @@ export * from './io';
 export * from './topic';
 export * from './policy';
 export * from './worker';
+export * from './task';

package/src/shared/task.ts

@@ -0,0 +1,30 @@
+import { lastValueFrom, Observable } from 'rxjs';
+import { Session } from './../session';
+
+declare type Task = (session: Session) => Observable<any> | Promise<any> | any;
+
+const tasks: Record<string, Task> = {};
+
+export function task(name: string, fn: Task) {
+  tasks[name] = fn;
+}
+
+export async function runTask(name: string, session: Session): Promise<void> {
+  const task = tasks[name];
+
+  if (!task) {
+    throw new Error('Unknown task: ' + name);
+  }
+
+  const result = tasks[name](session);
+
+  if (result instanceof Observable) {
+    return lastValueFrom(result);
+  }
+
+  if (result instanceof Promise) {
+    return await result;
+  }
+
+  return result;
+}

package/src/store/event/store-instrument.event.ts

@@ -23,7 +23,7 @@ export function InstrumentPatchEventHandler(event: InstrumentPatchEvent, state:
   const selector = new InstrumentSelector(
     event.base.name,
     event.quote.name,
-    event.base.exchange
+    event.base.adapter
   );
 
   let instrument = state.universe.instrument[selector.toString()];

package/src/store/event/store-order.event.ts

@@ -12,12 +12,6 @@ export class OrderLoadEvent implements StoreEvent {
 }
 
 export function OrderLoadEventHandler(event: OrderLoadEvent, state: State) {
-  const instrumentKey = event.order.instrument.toString();
-
-  if (!(instrumentKey in state.subscription.instrument)) {
-    throw new Error(`Trying to load order for unsubscribed instrument: ${instrumentKey}`);
-  }
-
   event.order.timestamp = event.timestamp;
 
   switch (event.order.state) {
@@ -48,12 +42,6 @@ export class OrderNewEvent implements StoreEvent {
 }
 
 export function OrderNewEventHandler(event: OrderNewEvent, state: State) {
-  const instrumentKey = event.order.instrument.toString();
-
-  if (!(instrumentKey in state.subscription.instrument)) {
-    throw new Error(`Trying to order for unsubscribed instrument: ${instrumentKey}`);
-  }
-
   if (event.order.state != 'NEW') {
     throw new Error(`Order is not new`);
   }

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

@@ -63,13 +63,17 @@ describe('backtester adapter tests', () => {
   });
 
   test('should stream data from input array', done => {
-    const streamer = new BacktesterStreamer(store, feed, {
-      balance: {
-        ['binance:usdt']: 1000
+    const streamer = new BacktesterStreamer(
+      store,
+      feed,
+      {
+        balance: {
+          ['binance:usdt']: 1000
+        },
+        from: 0,
+        to: 100
       },
-      from: 0,
-      to: 100,
-      listener: {
+      {
         onBacktestCompleted: () => {
           expect(store.snapshot.timestamp).toEqual(1);
           expect(store.snapshot.trade[instrument.toString()].rate).toEqual(100);
@@ -78,7 +82,7 @@ describe('backtester adapter tests', () => {
           done();
         }
       }
-    });
+    );
 
     feed.save(instrument, [new TradePatchEvent(instrument, 100, 10, 1)]);