@quantform/core 0.3.241 → 0.3.247

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,15 +16,25 @@ 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 streamer = new BacktesterStreamer(
+    store,
+    descriptor.feed,
+    descriptor.options.backtester,
+    listener
+  );
   const aggregate = new AdapterAggregate(
     store,
     descriptor.adapter.map(
-      it => new PaperAdapter(new BacktesterAdapter(it, streamer), store, options)
+      it =>
+        new PaperAdapter(
+          new BacktesterAdapter(it, streamer),
+          store,
+          descriptor.options.backtester
+        )
     )
   );
 
@@ -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))
   );
 
   return new Session(store, aggregate, descriptor);
@@ -59,14 +69,3 @@ export function live(descriptor: SessionDescriptor): Session {
 
   return new Session(store, aggregate, descriptor);
 }
-
-/**
- * Starts a new idle session.
- * @param descriptor session descriptor.
- */
-export function idle(descriptor: SessionDescriptor): Session {
-  const store = new Store();
-  const aggregate = new AdapterAggregate(store, descriptor.adapter);
-
-  return new Session(store, aggregate);
-}

package/src/ipc.spec.ts

@@ -9,10 +9,12 @@ import {
 } from './adapter';
 import { PaperAdapter, PaperSpotExecutor } from './adapter/paper';
 import { PaperExecutor } from './adapter/paper/executor/paper-executor';
-import { ipcSub, run } from './ipc';
+import { run } from './ipc';
 import { Feed, InMemoryStorage } from './storage';
 import { instrumentOf } from './domain';
-import { handler } from './shared';
+import { handler, task } from './shared';
+import { EventEmitter } from 'events';
+import { from, of, take, tap } from 'rxjs';
 
 class DefaultAdapter extends Adapter {
   name = 'default';
@@ -53,21 +55,21 @@ 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
     );
 
-    expect(session.descriptor).toBeUndefined();
+    //expect(session.descriptor).toBeUndefined();
   });
 
   test('should dispatch session started event', done => {
     const command = {
-      type: 'paper',
-      balance: { 'default:usd': 100 }
+      type: 'paper'
     };
 
+    const ipcSub = new EventEmitter();
+
     ipcSub.on('message', (message: any) => {
       expect(message.type).toBe('paper:started');
       done();
@@ -76,7 +78,33 @@ describe('ipc feed tests', () => {
     run(
       {
         adapter: [new DefaultAdapter()],
-        describe: (session: Session) => session.trade(instrumentOf('default:btc-usdt'))
+        ipcSub,
+        options: {
+          paper: {
+            balance: { 'default:usd': 100 }
+          }
+        }
+      },
+      command
+    );
+  });
+
+  test('should execute user task', done => {
+    task('hello-world', session => {
+      return of(1).pipe(
+        take(1),
+        tap(() => done())
+      );
+    });
+
+    const command = {
+      type: 'task',
+      taskName: 'hello-world'
+    };
+
+    run(
+      {
+        adapter: [new DefaultAdapter()]
       },
       command
     );

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';
-  adapter: 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,68 +156,55 @@ 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' });
 
@@ -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))?.default;
+
+    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();
     }
   }
 
@@ -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(

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-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)]);