@quantform/core 0.3.235 → 0.3.242

package/src/adapter/paper/paper-adapter.ts

@@ -43,13 +43,13 @@ export class PaperAdapter extends Adapter {
   @handler(AdapterAccountCommand)
   onAccount(event: AdapterAccountCommand, context: AdapterContext) {
     let subscribed = Object.values(this.store.snapshot.subscription.asset).filter(
-      it => it.exchange == this.name
+      it => it.adapter == this.name
     );
 
     for (const balance in this.options.balance) {
       const asset = assetOf(balance);
 
-      if (asset.exchange != this.name) {
+      if (asset.adapter != this.name) {
         continue;
       }
 

package/src/bin.ts

@@ -59,14 +59,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/domain/asset.spec.ts

@@ -5,7 +5,7 @@ describe('asset tests', () => {
     const sut = new Asset('abc', 'xyz', 4);
 
     expect(sut.name).toEqual('abc');
-    expect(sut.exchange).toEqual('xyz');
+    expect(sut.adapter).toEqual('xyz');
     expect(sut.scale).toEqual(4);
     expect(sut.tickSize).toEqual(0.0001);
     expect(sut.fixed(1.1234567)).toEqual(1.1234);
@@ -20,7 +20,7 @@ describe('asset selector tests', () => {
     const sut = assetOf('xyz:abc');
 
     expect(sut.name).toEqual('abc');
-    expect(sut.exchange).toEqual('xyz');
+    expect(sut.adapter).toEqual('xyz');
     expect(sut.toString()).toEqual('xyz:abc');
   });
 
@@ -28,7 +28,7 @@ describe('asset selector tests', () => {
     const sut = assetOf('XYZ:ABC');
 
     expect(sut.name).toEqual('abc');
-    expect(sut.exchange).toEqual('xyz');
+    expect(sut.adapter).toEqual('xyz');
     expect(sut.toString()).toEqual('xyz:abc');
   });
 
@@ -56,7 +56,7 @@ describe('asset selector tests', () => {
     expect(fn).toThrow(Error);
   });
 
-  test('should throw invalid format message for missing exchange name', () => {
+  test('should throw invalid format message for missing adapter name', () => {
     const fn = () => {
       assetOf(':abc');
     };

package/src/domain/asset.ts

@@ -7,13 +7,13 @@ export class AssetSelector {
   private readonly id: string;
 
   readonly name: string;
-  readonly exchange: string;
+  readonly adapter: string;
 
-  constructor(name: string, exchange: string) {
+  constructor(name: string, adapter: string) {
     this.name = name.toLowerCase();
-    this.exchange = exchange.toLowerCase();
+    this.adapter = adapter.toLowerCase();
 
-    this.id = `${this.exchange}:${this.name}`;
+    this.id = `${this.adapter}:${this.name}`;
   }
 
   /**
@@ -35,13 +35,13 @@ export function assetOf(asset: string): AssetSelector {
   }
 
   const assetName = section[1];
-  const exchangeName = section[0];
+  const adapterName = section[0];
 
-  if (assetName.length == 0 || exchangeName.length == 0) {
+  if (assetName.length == 0 || adapterName.length == 0) {
     throw Error('invalid asset format');
   }
 
-  return new AssetSelector(assetName, exchangeName);
+  return new AssetSelector(assetName, adapterName);
 }
 
 /**
@@ -51,8 +51,8 @@ export function assetOf(asset: string): AssetSelector {
 export class Asset extends AssetSelector {
   readonly tickSize: number;
 
-  constructor(name: string, exchange: string, public readonly scale: number) {
-    super(name, exchange);
+  constructor(name: string, adapter: string, public readonly scale: number) {
+    super(name, adapter);
 
     this.tickSize = 1.0 / Math.pow(10, this.scale);
   }

package/src/domain/instrument.spec.ts

@@ -10,9 +10,9 @@ describe('instrument tests', () => {
     );
 
     expect(sut.base.name).toEqual('abc');
-    expect(sut.base.exchange).toEqual('xyz');
+    expect(sut.base.adapter).toEqual('xyz');
     expect(sut.quote.name).toEqual('def');
-    expect(sut.quote.exchange).toEqual('xyz');
+    expect(sut.quote.adapter).toEqual('xyz');
     expect(sut.toString()).toEqual('xyz:abc-def');
   });
 });
@@ -22,9 +22,9 @@ describe('instrument selector tests', () => {
     const sut = instrumentOf('xyz:abc-def');
 
     expect(sut.base.name).toEqual('abc');
-    expect(sut.base.exchange).toEqual('xyz');
+    expect(sut.base.adapter).toEqual('xyz');
     expect(sut.quote.name).toEqual('def');
-    expect(sut.quote.exchange).toEqual('xyz');
+    expect(sut.quote.adapter).toEqual('xyz');
     expect(sut.toString()).toEqual('xyz:abc-def');
   });
 
@@ -32,9 +32,9 @@ describe('instrument selector tests', () => {
     const sut = instrumentOf('XYZ:ABC-DEF');
 
     expect(sut.base.name).toEqual('abc');
-    expect(sut.base.exchange).toEqual('xyz');
+    expect(sut.base.adapter).toEqual('xyz');
     expect(sut.quote.name).toEqual('def');
-    expect(sut.quote.exchange).toEqual('xyz');
+    expect(sut.quote.adapter).toEqual('xyz');
     expect(sut.toString()).toEqual('xyz:abc-def');
   });
 
@@ -62,7 +62,7 @@ describe('instrument selector tests', () => {
     expect(fn).toThrow(Error);
   });
 
-  test('should throw invalid format message for missing exchange name', () => {
+  test('should throw invalid format message for missing adapter name', () => {
     const fn = () => {
       assetOf(':abc-def');
     };

package/src/domain/instrument.ts

@@ -9,9 +9,9 @@ export class InstrumentSelector {
   readonly base: AssetSelector;
   readonly quote: AssetSelector;
 
-  constructor(base: string, quote: string, exchange: string) {
-    this.base = new AssetSelector(base.toLowerCase(), exchange.toLowerCase());
-    this.quote = new AssetSelector(quote.toLowerCase(), exchange.toLowerCase());
+  constructor(base: string, quote: string, adapter: string) {
+    this.base = new AssetSelector(base.toLowerCase(), adapter.toLowerCase());
+    this.quote = new AssetSelector(quote.toLowerCase(), adapter.toLowerCase());
 
     this.id = `${this.base.toString()}-${this.quote.name}`;
   }
@@ -31,10 +31,10 @@ export class Instrument extends InstrumentSelector implements Component {
   leverage?: number = null;
 
   constructor(readonly base: Asset, readonly quote: Asset, readonly raw: string) {
-    super(base.name, quote.name, base.exchange);
+    super(base.name, quote.name, base.adapter);
 
-    if (base.exchange != quote.exchange) {
-      throw new Error('Exchange mismatch!');
+    if (base.adapter != quote.adapter) {
+      throw new Error('Adapter mismatch!');
     }
   }
 }

package/src/domain/orderbook.ts

@@ -11,7 +11,7 @@ export class Orderbook implements Component {
   bestAskQuantity: number;
   bestBidRate: number;
   bestBidQuantity: number;
-  az;
+
   get midRate(): number {
     return this.instrument.quote.fixed((this.bestAskRate + this.bestBidRate) / 2);
   }

package/src/ipc.spec.ts

@@ -3,14 +3,18 @@ import {
   Adapter,
   AdapterFeedCommand,
   AdapterAwakeCommand,
-  AdapterAccountCommand
+  AdapterAccountCommand,
+  AdapterSubscribeCommand,
+  AdapterDisposeCommand
 } from './adapter';
 import { PaperAdapter, PaperSpotExecutor } from './adapter/paper';
 import { PaperExecutor } from './adapter/paper/executor/paper-executor';
-import { IpcFeedCommand, 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';
@@ -26,6 +30,12 @@ class DefaultAdapter extends Adapter {
   @handler(AdapterAwakeCommand)
   onAwake(command: AdapterAwakeCommand) {}
 
+  @handler(AdapterDisposeCommand)
+  onDispose(command: AdapterDisposeCommand) {}
+
+  @handler(AdapterSubscribeCommand)
+  onSubscribe(command: AdapterSubscribeCommand) {}
+
   @handler(AdapterAccountCommand)
   onAccount(command: AdapterAccountCommand) {}
 
@@ -51,6 +61,51 @@ describe('ipc feed tests', () => {
       command
     );
 
-    expect(session.descriptor).toBeUndefined();
+    //expect(session.descriptor).toBeUndefined();
+  });
+
+  test('should dispatch session started event', done => {
+    const command = {
+      type: 'paper',
+      balance: { 'default:usd': 100 }
+    };
+
+    const ipcSub = new EventEmitter();
+
+    ipcSub.on('message', (message: any) => {
+      expect(message.type).toBe('paper:started');
+      done();
+    });
+
+    run(
+      {
+        adapter: [new DefaultAdapter()],
+        describe: (session: Session) => session.trade(instrumentOf('default:btc-usdt')),
+        ipcSub
+      },
+      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()],
+        describe: (session: Session) => session.trade(instrumentOf('default:btc-usdt'))
+      },
+      command
+    );
   });
 });

package/src/ipc.ts

@@ -2,8 +2,10 @@ 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 { EventEmitter } from 'events';
 import minimist = require('minimist');
 
 /**
@@ -72,12 +74,6 @@ export class IpcBacktestCommand implements IpcCommand {
   balance: { [key: string]: number };
 }
 
-@event
-export class IpcUniverseQuery implements IpcCommand {
-  type = 'universe';
-  exchange: string;
-}
-
 /**
  * Feeds specific session descriptor with instrument data.
  */
@@ -101,6 +97,19 @@ export class IpcFeedCommand implements IpcCommand {
   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;
+}
+
 /**
  * Stores current session instance.
  */
@@ -108,11 +117,13 @@ class IpcSessionAccessor {
   session: Session;
 }
 
+export declare type SessionRunDescriptor = SessionDescriptor & { ipcSub?: EventEmitter };
+
 /**
  * Inter process communication handler.
  */
 class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
-  constructor(private readonly descriptor: SessionDescriptor) {
+  constructor(private readonly descriptor: SessionRunDescriptor) {
     super();
   }
 
@@ -127,6 +138,11 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
 
     accessor.session = live(this.descriptor);
 
+    this.notify({
+      type: 'live:started',
+      session: accessor.session.descriptor?.id
+    });
+
     await accessor.session.awake();
   }
 
@@ -143,6 +159,11 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
       balance: command.balance
     });
 
+    this.notify({
+      type: 'paper:started',
+      session: accessor.session.descriptor?.id
+    });
+
     await accessor.session.awake();
   }
 
@@ -156,55 +177,62 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
         from: command.from,
         to: command.to,
         balance: command.balance,
-        progress: timestamp =>
-          this.notify({
-            type: 'backtest:updated',
-            timestamp,
-            from: command.from,
-            to: command.to
-          }),
-        completed: async () => {
-          const statement = {};
-
-          await accessor.session.dispose();
-
-          this.notify({ type: 'backtest:completed', statement });
-
-          resolve();
+        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();
+          }
         }
       });
 
       accessor.session = session;
 
-      this.notify({ type: 'backtest:started' });
-
       await accessor.session.awake();
       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(true);
 
     this.notify({ type: 'feed:started' });
 
     await accessor.session.aggregate.dispatch(
-      instrument.base.exchange,
+      instrument.base.adapter,
       new AdapterFeedCommand(
         instrument,
         command.from,
@@ -225,15 +253,39 @@ 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(true);
+
+    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();
+  }
+
   /**
    * Sends a message to parent process.
    */
   private notify(message: any) {
-    if (!process.send) {
-      return;
+    if (process.send) {
+      process.send(message);
     }
 
-    process.send(message);
+    this.descriptor.ipcSub?.emit('message', message);
   }
 }
 
@@ -244,7 +296,7 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
  * @returns new session.
  */
 export async function run(
-  descriptor: SessionDescriptor,
+  descriptor: SessionRunDescriptor,
   ...commands: IpcCommand[]
 ): Promise<Session> {
   const handler = new IpcHandler(descriptor);

package/src/session/session.ts

@@ -57,7 +57,7 @@ export class Session {
     }
   }
 
-  async awake(): Promise<void> {
+  async awake(idle: boolean = false): Promise<void> {
     if (this.initialized) {
       return;
     }
@@ -67,7 +67,7 @@ export class Session {
     // awake all adapters and synchronize trading accounts with store.
     await this.aggregate.awake(this.descriptor != null);
 
-    if (this.descriptor?.describe) {
+    if (!idle && this.descriptor?.describe) {
       this.subscription = this.descriptor.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)
     );
   }
@@ -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/tests/backtester-adapter.spec.ts

@@ -69,12 +69,14 @@ describe('backtester adapter tests', () => {
       },
       from: 0,
       to: 100,
-      completed: () => {
-        expect(store.snapshot.timestamp).toEqual(1);
-        expect(store.snapshot.trade[instrument.toString()].rate).toEqual(100);
-        expect(store.snapshot.trade[instrument.toString()].quantity).toEqual(10);
+      listener: {
+        onBacktestCompleted: () => {
+          expect(store.snapshot.timestamp).toEqual(1);
+          expect(store.snapshot.trade[instrument.toString()].rate).toEqual(100);
+          expect(store.snapshot.trade[instrument.toString()].quantity).toEqual(10);
 
-        done();
+          done();
+        }
       }
     });