@quantform/core 0.5.15 → 0.6.4

package/src/adapter/adapter-aggregate.ts

@@ -1,9 +1,9 @@
 import { Candle, InstrumentSelector, Order } from '../domain';
-import { Logger } from '../shared';
+import { Logger, timestamp } from '../shared';
 import { Cache } from '../storage';
 import { Store } from '../store';
-import { Adapter, FeedQuery, HistoryQuery } from '.';
-import { AdapterFactory, AdapterTimeProvider } from './adapter';
+import { Adapter } from '.';
+import { AdapterFactory, AdapterTimeProvider, FeedAsyncCallback } from './adapter';
 import { adapterNotFoundError } from './error';
 
 /**
@@ -45,8 +45,8 @@ export class AdapterAggregate {
       try {
         await adapter.awake();
         await adapter.account();
-      } catch (e) {
-        Logger.error(e);
+      } catch (error) {
+        Logger.error(adapter.name, error);
       }
 
       this.adapter[adapter.name] = adapter;
@@ -56,12 +56,12 @@ export class AdapterAggregate {
   /**
    * Disposes all adapters.
    */
-  async dispose(): Promise<any> {
+  async dispose(): Promise<void> {
     for (const adapter of Object.values(this.adapter)) {
       try {
         await adapter.dispose();
-      } catch (e) {
-        Logger.error(e);
+      } catch (error) {
+        Logger.error(adapter.name, error);
       }
     }
   }
@@ -81,13 +81,17 @@ export class AdapterAggregate {
       }
 
       return aggregate;
-    }, {});
+    }, {} as Record<string, InstrumentSelector[]>);
 
     for (const adapterName in grouped) {
+      Logger.debug(adapterName, `subscribing for ${grouped[adapterName].join(', ')}`);
+
       try {
         await this.get(adapterName).subscribe(grouped[adapterName]);
-      } catch (e) {
-        Logger.error(e);
+      } catch (error) {
+        Logger.error(adapterName, error);
+
+        throw error;
       }
     }
   }
@@ -97,10 +101,19 @@ export class AdapterAggregate {
    * @param order an order to open.
    */
   async open(order: Order): Promise<void> {
+    const { adapterName } = order.instrument.base;
+
+    Logger.debug(
+      adapterName,
+      `opening a new order on ${order.instrument.toString()} as ${order.id}`
+    );
+
     try {
-      await this.get(order.instrument.base.adapterName).open(order);
-    } catch (e) {
-      Logger.error(e);
+      await this.get(adapterName).open(order);
+    } catch (error) {
+      Logger.error(adapterName, error);
+
+      throw error;
     }
   }
 
@@ -108,10 +121,16 @@ export class AdapterAggregate {
    * Cancels specific order.
    */
   cancel(order: Order): Promise<void> {
+    const { adapterName } = order.instrument.base;
+
+    Logger.debug(adapterName, `canceling a ${order.id} order`);
+
     try {
-      return this.get(order.instrument.base.adapterName).cancel(order);
-    } catch (e) {
-      Logger.error(e);
+      return this.get(adapterName).cancel(order);
+    } catch (error) {
+      Logger.error(adapterName, error);
+
+      throw error;
     }
   }
 
@@ -119,11 +138,17 @@ export class AdapterAggregate {
    *
    * @returns
    */
-  history(query: HistoryQuery): Promise<Candle[]> {
+  history(
+    instrument: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]> {
     try {
-      return this.get(query.instrument.base.adapterName).history(query);
-    } catch (e) {
-      Logger.error(e);
+      return this.get(instrument.base.adapterName).history(instrument, timeframe, length);
+    } catch (error) {
+      Logger.error(instrument.base.adapterName, error);
+
+      throw error;
     }
   }
 
@@ -131,11 +156,18 @@ export class AdapterAggregate {
    * Feeds a storage with historical instrument data.
    * @returns
    */
-  feed(query: FeedQuery): Promise<void> {
+  feed(
+    instrument: InstrumentSelector,
+    from: timestamp,
+    to: timestamp,
+    callback: FeedAsyncCallback
+  ): Promise<void> {
     try {
-      return this.get(query.instrument.base.adapterName).feed(query);
-    } catch (e) {
-      Logger.error(e);
+      return this.get(instrument.base.adapterName).feed(instrument, from, to, callback);
+    } catch (error) {
+      Logger.error(instrument.base.adapterName, error);
+
+      throw error;
     }
   }
 }

package/src/adapter/adapter.ts

@@ -1,6 +1,6 @@
 import { Candle, InstrumentSelector, Order } from '../domain';
 import { now, timestamp } from '../shared';
-import { Cache, Feed } from '../storage';
+import { Cache, StorageEvent } from '../storage';
 import { Store } from '../store';
 import { PaperAdapter } from './paper';
 import { PaperEngine } from './paper/engine/paper-engine';
@@ -13,26 +13,14 @@ export const DefaultTimeProvider = {
   timestamp: () => now()
 };
 
+export type FeedAsyncCallback = (timestamp: number, chunk: StorageEvent[]) => void;
+
 export type AdapterFactory = (
   timeProvider: AdapterTimeProvider,
   store: Store,
   cache: Cache
 ) => Adapter;
 
-export type HistoryQuery = {
-  instrument: InstrumentSelector;
-  timeframe: number;
-  length: number;
-};
-
-export type FeedQuery = {
-  instrument: InstrumentSelector;
-  from: timestamp;
-  to: timestamp;
-  destination: Feed;
-  callback: (timestamp: number) => void;
-};
-
 /**
  * Base adapter class, you should derive your own adapter from this class.
  * @abstract
@@ -78,9 +66,18 @@ export abstract class Adapter {
    */
   abstract cancel(order: Order): Promise<void>;
 
-  abstract history(query: HistoryQuery): Promise<Candle[]>;
-
-  abstract feed(query: FeedQuery): Promise<void>;
+  abstract history(
+    instrument: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]>;
+
+  abstract feed(
+    instrument: InstrumentSelector,
+    from: timestamp,
+    to: timestamp,
+    callback: FeedAsyncCallback
+  ): Promise<void>;
 
   abstract createPaperEngine(adapter: PaperAdapter): PaperEngine;
 }

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

@@ -2,7 +2,7 @@ import { Candle, InstrumentSelector, Order } from '../../domain';
 import { timestamp } from '../../shared';
 import { InstrumentSubscriptionEvent, Store } from '../../store';
 import { Adapter } from '..';
-import { AdapterFactory, FeedQuery, HistoryQuery } from '../adapter';
+import { AdapterFactory, FeedAsyncCallback } from '../adapter';
 import { PaperAdapter, PaperOptions } from '../paper';
 import { PaperEngine } from '../paper/engine/paper-engine';
 import { BacktesterStreamer } from './backtester-streamer';
@@ -53,8 +53,6 @@ export class BacktesterAdapter extends Adapter {
         it => new InstrumentSubscriptionEvent(this.timestamp(), it, true)
       )
     );
-
-    this.streamer.tryContinue();
   }
 
   account(): Promise<void> {
@@ -69,18 +67,27 @@ export class BacktesterAdapter extends Adapter {
     return this.decoratedAdapter.cancel(order);
   }
 
-  async history(query: HistoryQuery): Promise<Candle[]> {
+  async history(
+    instrument: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]> {
     this.streamer.stop();
 
-    const response = await this.decoratedAdapter.history(query);
+    const response = await this.decoratedAdapter.history(instrument, timeframe, length);
 
     this.streamer.tryContinue();
 
     return response;
   }
 
-  feed(query: FeedQuery): Promise<void> {
-    return this.decoratedAdapter.feed(query);
+  feed(
+    instrument: InstrumentSelector,
+    from: timestamp,
+    to: timestamp,
+    callback: FeedAsyncCallback
+  ): Promise<void> {
+    return this.decoratedAdapter.feed(instrument, from, to, callback);
   }
 
   createPaperEngine(adapter: PaperAdapter): PaperEngine {

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

@@ -1,5 +1,7 @@
-import { Candle, instrumentOf } from '../../domain';
+import { instrumentOf } from '../../domain';
+import { d } from '../../shared';
 import { Feed, InMemoryStorage } from '../../storage';
+import { TradePatchEvent } from '../../store';
 import { BacktesterCursor } from './backtester-cursor';
 
 describe('BacktesterCursor', () => {
@@ -8,35 +10,35 @@ describe('BacktesterCursor', () => {
     const feed = new Feed(new InMemoryStorage());
     const cursor = new BacktesterCursor(instrument, feed);
 
-    feed.save(instrument, [
-      new Candle(1, 1, 1, 1, 1),
-      new Candle(2, 2, 2, 2, 2),
-      new Candle(3, 3, 3, 3, 3),
-      new Candle(4, 4, 4, 4, 4),
-      new Candle(5, 5, 5, 5, 5),
-      new Candle(6, 6, 6, 6, 6),
-      new Candle(7, 7, 7, 7, 7),
-      new Candle(8, 8, 8, 8, 8)
+    feed.save([
+      new TradePatchEvent(instrument, d(1), d(1), 1),
+      new TradePatchEvent(instrument, d(2), d(2), 2),
+      new TradePatchEvent(instrument, d(3), d(3), 3),
+      new TradePatchEvent(instrument, d(4), d(4), 4),
+      new TradePatchEvent(instrument, d(5), d(5), 5),
+      new TradePatchEvent(instrument, d(6), d(6), 6),
+      new TradePatchEvent(instrument, d(7), d(7), 7),
+      new TradePatchEvent(instrument, d(8), d(8), 8)
     ]);
 
     await cursor.fetchNextPage(0, 4);
 
-    expect(cursor.dequeue().open).toEqual(1);
-    expect(cursor.dequeue().open).toEqual(2);
-    expect(cursor.dequeue().open).toEqual(3);
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(1), d(1), 1));
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(2), d(2), 2));
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(3), d(3), 3));
     expect(cursor.peek()).toEqual(undefined);
 
     await cursor.fetchNextPage(3, 7);
 
-    expect(cursor.dequeue().open).toEqual(4);
-    expect(cursor.dequeue().open).toEqual(5);
-    expect(cursor.dequeue().open).toEqual(6);
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(4), d(4), 4));
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(5), d(5), 5));
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(6), d(6), 6));
     expect(cursor.peek()).toEqual(undefined);
 
     await cursor.fetchNextPage(6, 10);
 
-    expect(cursor.dequeue().open).toEqual(7);
-    expect(cursor.dequeue().open).toEqual(8);
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(7), d(7), 7));
+    expect(cursor.dequeue()).toEqual(new TradePatchEvent(instrument, d(8), d(8), 8));
     expect(cursor.peek()).toEqual(undefined);
   });
 });

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

@@ -1,10 +1,10 @@
-import { Candle, InstrumentSelector } from '../../domain';
+import { InstrumentSelector } from '../../domain';
 import { timestamp } from '../../shared';
-import { Feed } from '../../storage';
+import { Feed, StorageEvent } from '../../storage';
 import { backtestPageNotEmpty } from '../error';
 
 export class BacktesterCursor {
-  private page = new Array<Candle>();
+  private page = new Array<StorageEvent>();
   private pageIndex = 0;
   completed = false;
 
@@ -12,9 +12,9 @@ export class BacktesterCursor {
     return this.page.length - this.pageIndex;
   }
 
-  constructor(readonly instrument: InstrumentSelector, private readonly feed: Feed) {}
+  constructor(readonly instrument: InstrumentSelector, private readonly feed: Feed) { }
 
-  peek(): Candle {
+  peek(): StorageEvent | undefined {
     if (!this.page) {
       return undefined;
     }
@@ -22,7 +22,7 @@ export class BacktesterCursor {
     return this.page[this.pageIndex];
   }
 
-  dequeue(): Candle {
+  dequeue(): StorageEvent {
     return this.page[this.pageIndex++];
   }
 

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

@@ -1,13 +1,16 @@
-import { Asset, Candle, Instrument } from '../../domain';
+import { Asset, Commission, Instrument } from '../../domain';
+import { d } from '../../shared';
 import { Feed, InMemoryStorage } from '../../storage';
-import { Store } from '../../store';
+import { Store, TradePatchEvent } from '../../store';
 import { BacktesterStreamer } from './backtester-streamer';
 
 describe('BacktesterStreamer', () => {
   const instrument = new Instrument(
+    0,
     new Asset('btc', 'binance', 8),
     new Asset('usdt', 'binance', 2),
-    'binance:btc-usdt'
+    'binance:btc-usdt',
+    Commission.Zero
   );
 
   test('should repeat specific events', done => {
@@ -26,11 +29,11 @@ describe('BacktesterStreamer', () => {
       },
       {
         onBacktestCompleted: () => {
-          const trade = store.snapshot.trade.get(instrument.id);
+          const trade = store.snapshot.trade.get(instrument.id) ?? fail();
 
           expect(trade.timestamp).toEqual(8);
-          expect(trade.rate).toEqual(8);
-          expect(trade.quantity).toEqual(8);
+          expect(trade.rate).toEqual(d(8));
+          expect(trade.quantity).toEqual(d(8));
           expect(store.snapshot.timestamp).toEqual(8);
 
           done();
@@ -39,15 +42,15 @@ describe('BacktesterStreamer', () => {
     );
 
     feed
-      .save(instrument, [
-        new Candle(1, 1, 1, 1, 1, 1),
-        new Candle(2, 2, 2, 2, 2, 2),
-        new Candle(3, 3, 3, 3, 3, 3),
-        new Candle(4, 4, 4, 4, 4, 4),
-        new Candle(5, 5, 5, 5, 5, 5),
-        new Candle(6, 6, 6, 6, 6, 6),
-        new Candle(7, 7, 7, 7, 7, 7),
-        new Candle(8, 8, 8, 8, 8, 8)
+      .save([
+        new TradePatchEvent(instrument, d(1), d(1), 1),
+        new TradePatchEvent(instrument, d(2), d(2), 2),
+        new TradePatchEvent(instrument, d(3), d(3), 3),
+        new TradePatchEvent(instrument, d(4), d(4), 4),
+        new TradePatchEvent(instrument, d(5), d(5), 5),
+        new TradePatchEvent(instrument, d(6), d(6), 6),
+        new TradePatchEvent(instrument, d(7), d(7), 7),
+        new TradePatchEvent(instrument, d(8), d(8), 8)
       ])
       .then(() => {
         streamer.subscribe(instrument);

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

@@ -1,9 +1,10 @@
 import { InstrumentSelector } from '../../domain';
 import { timestamp } from '../../shared';
 import { Feed } from '../../storage';
-import { OrderbookPatchEvent, Store, TradePatchEvent } from '../../store';
+import { Store } from '../../store';
 import { AdapterTimeProvider } from '../adapter';
 import { BacktesterCursor } from './backtester-cursor';
+import { invalidEventSequenceError, missingPeriodParametersError } from './error';
 
 /**
  * Listen to backtest session events.
@@ -40,7 +41,7 @@ export class BacktesterStreamer {
     private readonly listener?: BacktesterListener
   ) {
     if (period.from == undefined || period.to == undefined) {
-      throw new Error('invalid backtest options, please provide from and to period.');
+      throw missingPeriodParametersError();
     }
 
     this.timestamp = period.from;
@@ -86,7 +87,7 @@ export class BacktesterStreamer {
     }
 
     if (this.sequence == 0) {
-      if (this.listener.onBacktestStarted) {
+      if (this.listener?.onBacktestStarted) {
         this.listener.onBacktestStarted(this);
       }
     }
@@ -94,7 +95,7 @@ export class BacktesterStreamer {
     const next = async () => {
       if (await this.processNext()) {
         if (this.sequence % this.sequenceUpdateBatch == 0) {
-          if (this.listener.onBacktestUpdated) {
+          if (this.listener?.onBacktestUpdated) {
             this.listener.onBacktestUpdated(this);
           }
         }
@@ -103,7 +104,7 @@ export class BacktesterStreamer {
           setImmediate(next);
         }
       } else {
-        if (this.listener.onBacktestCompleted) {
+        if (this.listener?.onBacktestCompleted) {
           this.listener.onBacktestCompleted(this);
         }
       }
@@ -118,38 +119,28 @@ export class BacktesterStreamer {
       return false;
     }
 
-    const candle = cursor.peek();
-    const instrument = cursor.instrument;
-    const volume = candle.volume ?? 0;
+    const event = cursor.peek();
 
-    this.timestamp = candle.timestamp;
+    if (!event) {
+      return false;
+    }
+
+    this.timestamp = event.timestamp;
     this.sequence++;
 
-    this.dispatch(candle.timestamp, instrument, candle.open, volume);
-    this.dispatch(candle.timestamp, instrument, candle.high, volume);
-    this.dispatch(candle.timestamp, instrument, candle.low, volume);
-    this.dispatch(candle.timestamp, instrument, candle.close, volume);
+    this.store.dispatch(event);
 
-    if (cursor.dequeue().timestamp != candle.timestamp) {
-      throw new Error('invalid event to consume');
+    if (cursor.dequeue().timestamp != event.timestamp) {
+      throw invalidEventSequenceError();
     }
 
     return true;
   }
 
-  private dispatch(
-    timestamp: number,
-    instrument: InstrumentSelector,
-    rate: number,
-    volume: number
-  ) {
-    this.store.dispatch(
-      new TradePatchEvent(instrument, rate, volume, timestamp),
-      new OrderbookPatchEvent(instrument, rate, volume, rate, volume, timestamp)
-    );
-  }
-
-  private async current(from: timestamp, to: timestamp): Promise<BacktesterCursor> {
+  private async current(
+    from: timestamp,
+    to: timestamp
+  ): Promise<BacktesterCursor | undefined> {
     for (const cursor of Object.values(this.cursor)) {
       if (cursor.size == 0 && !cursor.completed) {
         await cursor.fetchNextPage(from, to);
@@ -157,8 +148,8 @@ export class BacktesterStreamer {
     }
 
     return Object.values(this.cursor)
-      .filter(it => it.peek() != undefined)
-      .sort((lhs, rhs) => lhs.peek().timestamp - rhs.peek().timestamp)
+      .filter(it => it !== undefined)
+      .sort((lhs, rhs) => (lhs?.peek()?.timestamp ?? 0) - (rhs?.peek()?.timestamp ?? 0))
       .find(() => true);
   }
 }

package/src/adapter/backtester/error.ts

@@ -0,0 +1,7 @@
+export function missingPeriodParametersError() {
+  return new Error('invalid backtest options, please provide from and to period.');
+}
+
+export function invalidEventSequenceError() {
+  return new Error('invalid event to consume');
+}

package/src/adapter/error.ts

@@ -4,6 +4,10 @@ export function adapterNotFoundError(adapterName: string) {
   );
 }
 
+export function noPaperEngineProvidedError() {
+  return new Error('No paper engine provided.');
+}
+
 export function backtestPageNotEmpty() {
   return new Error('Backtest page is not empty');
 }