@quantform/core 0.4.11 → 0.5.15

package/src/adapter/adapter-aggregate.ts

@@ -1,7 +1,10 @@
-import { Adapter, AdapterContext, FeedQuery, HistoryQuery } from '.';
 import { Candle, InstrumentSelector, Order } from '../domain';
 import { Logger } from '../shared';
+import { Cache } from '../storage';
 import { Store } from '../store';
+import { Adapter, FeedQuery, HistoryQuery } from '.';
+import { AdapterFactory, AdapterTimeProvider } from './adapter';
+import { adapterNotFoundError } from './error';
 
 /**
  * Manages instances of all adapters provided in session descriptor.
@@ -10,9 +13,12 @@ import { Store } from '../store';
 export class AdapterAggregate {
   private readonly adapter: Record<string, Adapter> = {};
 
-  constructor(adapters: Adapter[], private readonly store: Store) {
-    adapters.forEach(it => (this.adapter[it.name] = it));
-  }
+  constructor(
+    private readonly factories: AdapterFactory[],
+    private readonly timeProvider: AdapterTimeProvider,
+    private readonly store: Store,
+    private readonly cache: Cache
+  ) {}
 
   /**
    * Returns adapter by name.
@@ -23,9 +29,7 @@ export class AdapterAggregate {
     const adapter = this.adapter[adapterName];
 
     if (!adapter) {
-      throw new Error(
-        `Unknown adapter: ${adapterName}. You should provide adapter in session descriptor.`
-      );
+      throw adapterNotFoundError(adapterName);
     }
 
     return adapter;
@@ -35,13 +39,17 @@ export class AdapterAggregate {
    * Sets up all adapters.
    */
   async awake(): Promise<void> {
-    for (const adapter of Object.values(this.adapter)) {
+    for (const factory of this.factories) {
+      const adapter = factory(this.timeProvider, this.store, this.cache);
+
       try {
-        await adapter.awake(this.createContext(adapter));
+        await adapter.awake();
         await adapter.account();
       } catch (e) {
         Logger.error(e);
       }
+
+      this.adapter[adapter.name] = adapter;
     }
   }
 
@@ -63,19 +71,17 @@ export class AdapterAggregate {
    * @param selectors
    */
   async subscribe(selectors: InstrumentSelector[]): Promise<void> {
-    const grouped = selectors
-      .filter(it => it != null)
-      .reduce((aggregate, it) => {
-        const adapter = it.base.adapter;
+    const grouped = selectors.reduce((aggregate, it) => {
+      const adapter = it.base.adapterName;
 
-        if (aggregate[adapter]) {
-          aggregate[adapter].push(it);
-        } else {
-          aggregate[adapter] = [it];
-        }
+      if (aggregate[adapter]) {
+        aggregate[adapter].push(it);
+      } else {
+        aggregate[adapter] = [it];
+      }
 
-        return aggregate;
-      }, {});
+      return aggregate;
+    }, {});
 
     for (const adapterName in grouped) {
       try {
@@ -90,9 +96,9 @@ export class AdapterAggregate {
    * Opens new order.
    * @param order an order to open.
    */
-  open(order: Order): Promise<void> {
+  async open(order: Order): Promise<void> {
     try {
-      return this.get(order.instrument.base.adapter).open(order);
+      await this.get(order.instrument.base.adapterName).open(order);
     } catch (e) {
       Logger.error(e);
     }
@@ -103,7 +109,7 @@ export class AdapterAggregate {
    */
   cancel(order: Order): Promise<void> {
     try {
-      return this.get(order.instrument.base.adapter).cancel(order);
+      return this.get(order.instrument.base.adapterName).cancel(order);
     } catch (e) {
       Logger.error(e);
     }
@@ -115,7 +121,7 @@ export class AdapterAggregate {
    */
   history(query: HistoryQuery): Promise<Candle[]> {
     try {
-      return this.get(query.instrument.base.adapter).history(query);
+      return this.get(query.instrument.base.adapterName).history(query);
     } catch (e) {
       Logger.error(e);
     }
@@ -127,18 +133,9 @@ export class AdapterAggregate {
    */
   feed(query: FeedQuery): Promise<void> {
     try {
-      return this.get(query.instrument.base.adapter).feed(query);
+      return this.get(query.instrument.base.adapterName).feed(query);
     } catch (e) {
       Logger.error(e);
     }
   }
-
-  /**
-   *
-   * @param adapter
-   * @returns
-   */
-  private createContext(adapter: Adapter) {
-    return new AdapterContext(adapter, this.store);
-  }
 }

package/src/adapter/adapter.ts

@@ -1,31 +1,23 @@
 import { Candle, InstrumentSelector, Order } from '../domain';
 import { now, timestamp } from '../shared';
-import { Feed } from '../storage';
-import { State, Store, StoreEvent } from '../store';
+import { Cache, Feed } from '../storage';
+import { Store } from '../store';
 import { PaperAdapter } from './paper';
-import { PaperSimulator } from './paper/simulator/paper-simulator';
+import { PaperEngine } from './paper/engine/paper-engine';
 
-/**
- * Shared context for adapter execution. Provides access to the store.
- */
-export class AdapterContext {
-  /**
-   * Returns the current unix timestamp (points to historical date in case of backtest).
-   */
-  get timestamp(): timestamp {
-    return this.adapter.timestamp();
-  }
-
-  get snapshot(): State {
-    return this.store.snapshot;
-  }
+export type AdapterTimeProvider = {
+  timestamp: () => number;
+};
 
-  constructor(private readonly adapter: Adapter, private readonly store: Store) {}
+export const DefaultTimeProvider = {
+  timestamp: () => now()
+};
 
-  dispatch(...events: StoreEvent[]) {
-    return this.store.dispatch(...events);
-  }
-}
+export type AdapterFactory = (
+  timeProvider: AdapterTimeProvider,
+  store: Store,
+  cache: Cache
+) => Adapter;
 
 export type HistoryQuery = {
   instrument: InstrumentSelector;
@@ -46,64 +38,49 @@ export type FeedQuery = {
  * @abstract
  */
 export abstract class Adapter {
-  context: AdapterContext;
-
   abstract name: string;
 
   timestamp(): timestamp {
-    return now();
+    return this.timeProvider.timestamp();
   }
 
+  constructor(private readonly timeProvider: AdapterTimeProvider) {}
+
   /**
    * Setup an adapter.
-   * @param context
    */
-  async awake(context: AdapterContext): Promise<void> {
-    this.context = context;
-  }
+  abstract awake(): Promise<void>;
 
   /**
    * Dispose an adapter.
    */
-  async dispose(): Promise<void> {}
+  abstract dispose(): Promise<void>;
 
   /**
    * Subscribe to collection of instruments.
    * @param instruments
    */
-  subscribe(instruments: InstrumentSelector[]): Promise<void> {
-    throw new Error('method not implemented');
-  }
+  abstract subscribe(instruments: InstrumentSelector[]): Promise<void>;
 
   /**
    *
    */
-  account(): Promise<void> {
-    throw new Error('method not implemented');
-  }
+  abstract account(): Promise<void>;
 
   /**
    * Opens new order.
    * @param order an order to open.
    */
-  open(order: Order): Promise<void> {
-    throw new Error('method not implemented');
-  }
+  abstract open(order: Order): Promise<void>;
 
   /**
    * Cancels specific order.
    */
-  cancel(order: Order): Promise<void> {
-    throw new Error('method not implemented');
-  }
+  abstract cancel(order: Order): Promise<void>;
 
-  history(query: HistoryQuery): Promise<Candle[]> {
-    throw new Error('method not implemented');
-  }
+  abstract history(query: HistoryQuery): Promise<Candle[]>;
 
-  feed(query: FeedQuery): Promise<void> {
-    throw new Error('method not implemented');
-  }
+  abstract feed(query: FeedQuery): Promise<void>;
 
-  abstract createPaperSimulator(adapter: PaperAdapter): PaperSimulator;
+  abstract createPaperEngine(adapter: PaperAdapter): PaperEngine;
 }

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

@@ -0,0 +1,124 @@
+import {
+  Asset,
+  Candle,
+  Commission,
+  instrumentOf,
+  InstrumentSelector,
+  Order
+} from '../../domain';
+import { Cache, Feed, InMemoryStorage } from '../../storage';
+import { InstrumentPatchEvent, Store } from '../../store';
+import {
+  Adapter,
+  AdapterTimeProvider,
+  DefaultTimeProvider,
+  FeedQuery,
+  HistoryQuery
+} from '../adapter';
+import { PaperEngine } from '../paper/engine/paper-engine';
+import { PaperAdapter } from '../paper/paper-adapter';
+import { BacktesterAdapter } from './backtester-adapter';
+import { BacktesterStreamer } from './backtester-streamer';
+
+const base = new Asset('btc', 'binance', 8);
+const quote = new Asset('usdt', 'binance', 4);
+
+class DefaultAdapter extends Adapter {
+  dispose(): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  subscribe(instruments: InstrumentSelector[]): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  account(): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  open(order: Order): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  cancel(order: Order): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  history(query: HistoryQuery): Promise<Candle[]> {
+    throw new Error('Method not implemented.');
+  }
+  feed(query: FeedQuery): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  name = 'default';
+
+  constructor(timeProvider: AdapterTimeProvider, private readonly store: Store) {
+    super(timeProvider);
+  }
+
+  timestamp() {
+    return 123;
+  }
+
+  createPaperEngine(adapter: PaperAdapter): PaperEngine {
+    return new PaperEngine(adapter.store);
+  }
+
+  async awake(): Promise<void> {
+    this.store.dispatch(
+      new InstrumentPatchEvent(
+        this.timestamp(),
+        base,
+        quote,
+        new Commission(0.1, 0.1),
+        'btc-usdt'
+      )
+    );
+  }
+}
+
+const instrument = instrumentOf('binance:btc-usdt');
+const store = new Store();
+const adapter = new DefaultAdapter(DefaultTimeProvider, store);
+const feed = new Feed(new InMemoryStorage());
+const cache = new Cache(new InMemoryStorage());
+
+describe('BacktesterAdapter', () => {
+  test('should return proper adapter name and timestamp', () => {
+    const sut = new BacktesterAdapter(
+      adapter,
+      new BacktesterStreamer(store, feed, {
+        from: 1,
+        to: 100
+      }),
+      store
+    );
+
+    expect(sut.name).toEqual('default');
+    expect(sut.timestamp()).toEqual(1);
+  });
+
+  test('should stream data from input array', done => {
+    const streamer = new BacktesterStreamer(
+      store,
+      feed,
+      {
+        from: 0,
+        to: 100
+      },
+      {
+        onBacktestCompleted: () => {
+          expect(store.snapshot.timestamp).toEqual(1);
+          expect(store.snapshot.trade.get(instrument.id).rate).toEqual(100);
+          expect(store.snapshot.trade.get(instrument.id).quantity).toEqual(10);
+
+          done();
+        }
+      }
+    );
+
+    feed.save(instrument, [new Candle(1, 100, 100, 100, 100, 10)]);
+
+    const sut = new BacktesterAdapter(adapter, streamer, store);
+
+    sut.awake();
+    sut.subscribe([instrument]);
+
+    expect(sut.name).toEqual('default');
+  });
+});

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

@@ -1,10 +1,10 @@
-import { Adapter, AdapterContext } from '..';
 import { Candle, InstrumentSelector, Order } from '../../domain';
 import { timestamp } from '../../shared';
-import { InstrumentSubscriptionEvent } from '../../store';
-import { FeedQuery, HistoryQuery } from '../adapter';
+import { InstrumentSubscriptionEvent, Store } from '../../store';
+import { Adapter } from '..';
+import { AdapterFactory, FeedQuery, HistoryQuery } from '../adapter';
 import { PaperAdapter, PaperOptions } from '../paper';
-import { PaperSimulator } from '../paper/simulator/paper-simulator';
+import { PaperEngine } from '../paper/engine/paper-engine';
 import { BacktesterStreamer } from './backtester-streamer';
 
 export interface BacktesterOptions extends PaperOptions {
@@ -12,20 +12,31 @@ export interface BacktesterOptions extends PaperOptions {
   to: timestamp;
 }
 
+export function createBacktesterAdapterFactory(
+  decoratedAdapterFactory: AdapterFactory,
+  streamer: BacktesterStreamer
+): AdapterFactory {
+  return (timeProvider, store, cache) =>
+    new BacktesterAdapter(
+      decoratedAdapterFactory(timeProvider, store, cache),
+      streamer,
+      store
+    );
+}
+
 export class BacktesterAdapter extends Adapter {
   readonly name = this.decoratedAdapter.name;
 
-  timestamp() {
-    return this.streamer.timestamp;
+  constructor(
+    readonly decoratedAdapter: Adapter,
+    readonly streamer: BacktesterStreamer,
+    readonly store: Store
+  ) {
+    super(streamer.getTimeProvider());
   }
 
-  constructor(readonly decoratedAdapter: Adapter, readonly streamer: BacktesterStreamer) {
-    super();
-  }
-
-  async awake(context: AdapterContext): Promise<void> {
-    await super.awake(context);
-    await this.decoratedAdapter.awake(context);
+  async awake(): Promise<void> {
+    await this.decoratedAdapter.awake();
   }
 
   dispose(): Promise<void> {
@@ -37,11 +48,13 @@ export class BacktesterAdapter extends Adapter {
       this.streamer.subscribe(it);
     });
 
-    this.context.dispatch(
+    this.store.dispatch(
       ...instruments.map(
-        it => new InstrumentSubscriptionEvent(this.context.timestamp, it, true)
+        it => new InstrumentSubscriptionEvent(this.timestamp(), it, true)
       )
     );
+
+    this.streamer.tryContinue();
   }
 
   account(): Promise<void> {
@@ -70,7 +83,7 @@ export class BacktesterAdapter extends Adapter {
     return this.decoratedAdapter.feed(query);
   }
 
-  createPaperSimulator(adapter: PaperAdapter): PaperSimulator {
-    return this.decoratedAdapter.createPaperSimulator(adapter);
+  createPaperEngine(adapter: PaperAdapter): PaperEngine {
+    return this.decoratedAdapter.createPaperEngine(adapter);
   }
 }

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

@@ -1,43 +1,42 @@
-import { instrumentOf } from '../../domain';
+import { Candle, instrumentOf } from '../../domain';
 import { Feed, InMemoryStorage } from '../../storage';
-import { TradePatchEvent } from '../../store';
 import { BacktesterCursor } from './backtester-cursor';
 
-describe('backtester cursor tests', () => {
+describe('BacktesterCursor', () => {
   test('should repeat specific events', async () => {
     const instrument = instrumentOf('binance:btc-usdt');
     const feed = new Feed(new InMemoryStorage());
     const cursor = new BacktesterCursor(instrument, feed);
 
     feed.save(instrument, [
-      new TradePatchEvent(instrument, 1, 1, 1),
-      new TradePatchEvent(instrument, 2, 1, 2),
-      new TradePatchEvent(instrument, 3, 1, 3),
-      new TradePatchEvent(instrument, 4, 1, 4),
-      new TradePatchEvent(instrument, 5, 1, 5),
-      new TradePatchEvent(instrument, 6, 1, 6),
-      new TradePatchEvent(instrument, 7, 1, 7),
-      new TradePatchEvent(instrument, 8, 1, 8)
+      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)
     ]);
 
     await cursor.fetchNextPage(0, 4);
 
-    expect(cursor.dequeue<TradePatchEvent>().rate).toEqual(1);
-    expect(cursor.dequeue<TradePatchEvent>().rate).toEqual(2);
-    expect(cursor.dequeue<TradePatchEvent>().rate).toEqual(3);
+    expect(cursor.dequeue().open).toEqual(1);
+    expect(cursor.dequeue().open).toEqual(2);
+    expect(cursor.dequeue().open).toEqual(3);
     expect(cursor.peek()).toEqual(undefined);
 
     await cursor.fetchNextPage(3, 7);
 
-    expect(cursor.dequeue<TradePatchEvent>().rate).toEqual(4);
-    expect(cursor.dequeue<TradePatchEvent>().rate).toEqual(5);
-    expect(cursor.dequeue<TradePatchEvent>().rate).toEqual(6);
+    expect(cursor.dequeue().open).toEqual(4);
+    expect(cursor.dequeue().open).toEqual(5);
+    expect(cursor.dequeue().open).toEqual(6);
     expect(cursor.peek()).toEqual(undefined);
 
     await cursor.fetchNextPage(6, 10);
 
-    expect(cursor.dequeue<TradePatchEvent>().rate).toEqual(7);
-    expect(cursor.dequeue<TradePatchEvent>().rate).toEqual(8);
+    expect(cursor.dequeue().open).toEqual(7);
+    expect(cursor.dequeue().open).toEqual(8);
     expect(cursor.peek()).toEqual(undefined);
   });
 });

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

@@ -1,10 +1,10 @@
-import { InstrumentSelector } from '../../domain';
+import { Candle, InstrumentSelector } from '../../domain';
 import { timestamp } from '../../shared';
 import { Feed } from '../../storage';
-import { StoreEvent } from '../../store';
+import { backtestPageNotEmpty } from '../error';
 
 export class BacktesterCursor {
-  private page = new Array<StoreEvent>();
+  private page = new Array<Candle>();
   private pageIndex = 0;
   completed = false;
 
@@ -14,7 +14,7 @@ export class BacktesterCursor {
 
   constructor(readonly instrument: InstrumentSelector, private readonly feed: Feed) {}
 
-  peek(): StoreEvent {
+  peek(): Candle {
     if (!this.page) {
       return undefined;
     }
@@ -22,8 +22,8 @@ export class BacktesterCursor {
     return this.page[this.pageIndex];
   }
 
-  dequeue<T extends StoreEvent>(): T {
-    return this.page[this.pageIndex++] as T;
+  dequeue(): Candle {
+    return this.page[this.pageIndex++];
   }
 
   async fetchNextPage(from: timestamp, to: number): Promise<void> {
@@ -32,7 +32,7 @@ export class BacktesterCursor {
     }
 
     if (this.size > 0) {
-      throw new Error('page is not empty');
+      throw backtestPageNotEmpty();
     }
 
     this.pageIndex = 0;

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

@@ -1,21 +1,21 @@
-import { Asset, Instrument, Timeframe } from '../../domain';
+import { Asset, Candle, Instrument } from '../../domain';
 import { Feed, InMemoryStorage } from '../../storage';
-import { CandleEvent, Store } from '../../store';
+import { Store } from '../../store';
 import { BacktesterStreamer } from './backtester-streamer';
 
-const instrument = new Instrument(
-  new Asset('btc', 'binance', 8),
-  new Asset('usdt', 'binance', 2),
-  'binance:btc-usdt'
-);
+describe('BacktesterStreamer', () => {
+  const instrument = new Instrument(
+    new Asset('btc', 'binance', 8),
+    new Asset('usdt', 'binance', 2),
+    'binance:btc-usdt'
+  );
 
-describe('backtester streamer tests', () => {
   test('should repeat specific events', done => {
     const feed = new Feed(new InMemoryStorage());
     const store = new Store();
 
-    store.snapshot.universe.instrument[instrument.toString()] = instrument;
-    store.snapshot.subscription.instrument[instrument.toString()] = instrument;
+    store.snapshot.universe.instrument.upsert(instrument);
+    store.snapshot.subscription.instrument.upsert(instrument);
 
     const streamer = new BacktesterStreamer(
       store,
@@ -26,7 +26,7 @@ describe('backtester streamer tests', () => {
       },
       {
         onBacktestCompleted: () => {
-          const trade = store.snapshot.trade[instrument.toString()];
+          const trade = store.snapshot.trade.get(instrument.id);
 
           expect(trade.timestamp).toEqual(8);
           expect(trade.rate).toEqual(8);
@@ -40,14 +40,14 @@ describe('backtester streamer tests', () => {
 
     feed
       .save(instrument, [
-        new CandleEvent(instrument, Timeframe.M1, 1, 1, 1, 1, 1, 1),
-        new CandleEvent(instrument, Timeframe.M1, 2, 2, 2, 2, 2, 2),
-        new CandleEvent(instrument, Timeframe.M1, 3, 3, 3, 3, 3, 3),
-        new CandleEvent(instrument, Timeframe.M1, 4, 4, 4, 4, 4, 4),
-        new CandleEvent(instrument, Timeframe.M1, 5, 5, 5, 5, 5, 5),
-        new CandleEvent(instrument, Timeframe.M1, 6, 6, 6, 6, 6, 6),
-        new CandleEvent(instrument, Timeframe.M1, 7, 7, 7, 7, 7, 7),
-        new CandleEvent(instrument, Timeframe.M1, 8, 8, 8, 8, 8, 8)
+        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)
       ])
       .then(() => {
         streamer.subscribe(instrument);