@quantform/core 0.5.13 → 0.5.23

package/src/adapter/adapter-aggregate.ts

@@ -1,8 +1,10 @@
 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, AdapterContext, FeedQuery, HistoryQuery } from '.';
+import { Adapter } from '.';
+import { AdapterFactory, AdapterTimeProvider, FeedAsyncCallback } from './adapter';
+import { adapterNotFoundError } from './error';
 
 /**
  * Manages instances of all adapters provided in session descriptor.
@@ -12,12 +14,11 @@ export class AdapterAggregate {
   private readonly adapter: Record<string, Adapter> = {};
 
   constructor(
-    adapters: Adapter[],
+    private readonly factories: AdapterFactory[],
+    private readonly timeProvider: AdapterTimeProvider,
     private readonly store: Store,
     private readonly cache: Cache
-  ) {
-    adapters.forEach(it => (this.adapter[it.name] = it));
-  }
+  ) {}
 
   /**
    * Returns adapter by name.
@@ -28,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;
@@ -40,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;
     }
   }
 
@@ -68,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 {
@@ -95,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);
     }
@@ -108,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);
     }
@@ -118,9 +119,13 @@ 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.adapter).history(query);
+      return this.get(instrument.base.adapterName).history(instrument, timeframe, length);
     } catch (e) {
       Logger.error(e);
     }
@@ -130,20 +135,16 @@ 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.adapter).feed(query);
+      return this.get(instrument.base.adapterName).feed(instrument, from, to, callback);
     } catch (e) {
       Logger.error(e);
     }
   }
-
-  /**
-   *
-   * @param adapter
-   * @returns
-   */
-  private createContext(adapter: Adapter) {
-    return new AdapterContext(adapter, this.store, this.cache);
-  }
 }

package/src/adapter/adapter.ts

@@ -1,115 +1,83 @@
 import { Candle, InstrumentSelector, Order } from '../domain';
 import { now, timestamp } from '../shared';
-import { Cache, Feed } from '../storage';
-import { State, Store, StoreEvent } from '../store';
+import { Cache, StorageEvent } 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;
-  }
-
-  constructor(
-    private readonly adapter: Adapter,
-    private readonly store: Store,
-    readonly cache: Cache
-  ) {}
-
-  dispatch(...events: StoreEvent[]) {
-    return this.store.dispatch(...events);
-  }
-}
-
-export type HistoryQuery = {
-  instrument: InstrumentSelector;
-  timeframe: number;
-  length: number;
+export type AdapterTimeProvider = {
+  timestamp: () => number;
 };
 
-export type FeedQuery = {
-  instrument: InstrumentSelector;
-  from: timestamp;
-  to: timestamp;
-  destination: Feed;
-  callback: (timestamp: number) => void;
+export const DefaultTimeProvider = {
+  timestamp: () => now()
 };
 
+export type FeedAsyncCallback = (timestamp: number, chunk: StorageEvent[]) => void;
+
+export type AdapterFactory = (
+  timeProvider: AdapterTimeProvider,
+  store: Store,
+  cache: Cache
+) => Adapter;
+
 /**
  * Base adapter class, you should derive your own adapter from this class.
  * @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> {
-    throw new Error('method not implemented');
-  }
+  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');
-  }
-
-  history(query: HistoryQuery): Promise<Candle[]> {
-    throw new Error('method not implemented');
-  }
-
-  feed(query: FeedQuery): Promise<void> {
-    throw new Error('method not implemented');
-  }
-
-  abstract createPaperSimulator(adapter: PaperAdapter): PaperSimulator;
+  abstract cancel(order: Order): 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.spec.ts

@@ -0,0 +1,133 @@
+import {
+  Asset,
+  Candle,
+  Commission,
+  instrumentOf,
+  InstrumentSelector,
+  Order
+} from '../../domain';
+import { d, timestamp } from '../../shared';
+import { Cache, Feed, InMemoryStorage } from '../../storage';
+import { InstrumentPatchEvent, Store, TradePatchEvent } from '../../store';
+import {
+  Adapter,
+  AdapterTimeProvider,
+  DefaultTimeProvider,
+  FeedAsyncCallback
+} 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(
+    instrument: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]> {
+    throw new Error('Method not implemented.');
+  }
+  feed(
+    instrument: InstrumentSelector,
+    from: timestamp,
+    to: timestamp,
+    callback: FeedAsyncCallback
+  ): 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(d(0.1), d(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(d(100));
+          expect(store.snapshot.trade.get(instrument.id).quantity).toEqual(d(10));
+
+          done();
+        }
+      }
+    );
+
+    feed.save([new TradePatchEvent(instrument, d(100), d(10), 1)]);
+
+    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 { Candle, InstrumentSelector, Order } from '../../domain';
 import { timestamp } from '../../shared';
-import { InstrumentSubscriptionEvent } from '../../store';
-import { Adapter, AdapterContext } from '..';
-import { FeedQuery, HistoryQuery } from '../adapter';
+import { InstrumentSubscriptionEvent, Store } from '../../store';
+import { Adapter } from '..';
+import { AdapterFactory, FeedAsyncCallback } 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) {
-    super();
+  constructor(
+    readonly decoratedAdapter: Adapter,
+    readonly streamer: BacktesterStreamer,
+    readonly store: Store
+  ) {
+    super(streamer.getTimeProvider());
   }
 
-  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,9 +48,9 @@ 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)
       )
     );
 
@@ -58,21 +69,30 @@ 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);
   }
 
-  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,44 @@
 import { instrumentOf } from '../../domain';
+import { d } from '../../shared';
 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)
+    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<TradePatchEvent>().rate).toEqual(1);
-    expect(cursor.dequeue<TradePatchEvent>().rate).toEqual(2);
-    expect(cursor.dequeue<TradePatchEvent>().rate).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<TradePatchEvent>().rate).toEqual(4);
-    expect(cursor.dequeue<TradePatchEvent>().rate).toEqual(5);
-    expect(cursor.dequeue<TradePatchEvent>().rate).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<TradePatchEvent>().rate).toEqual(7);
-    expect(cursor.dequeue<TradePatchEvent>().rate).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 { InstrumentSelector } from '../../domain';
 import { timestamp } from '../../shared';
-import { Feed } from '../../storage';
-import { StoreEvent } from '../../store';
+import { Feed, StorageEvent } from '../../storage';
+import { backtestPageNotEmpty } from '../error';
 
 export class BacktesterCursor {
-  private page = new Array<StoreEvent>();
+  private page = new Array<StorageEvent>();
   private pageIndex = 0;
   completed = false;
 
@@ -14,7 +14,7 @@ export class BacktesterCursor {
 
   constructor(readonly instrument: InstrumentSelector, private readonly feed: Feed) {}
 
-  peek(): StoreEvent {
+  peek(): StorageEvent {
     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(): StorageEvent {
+    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;