@quantform/core 0.6.7 → 0.7.0-beta.5

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

@@ -1,100 +0,0 @@
-import {
-  Adapter,
-  AdapterFactory,
-  BacktesterStreamer,
-  FeedAsyncCallback,
-  PaperAdapter,
-  PaperEngine,
-  PaperOptions
-} from '@lib/adapter';
-import { InstrumentSelector, Ohlc, Order } from '@lib/domain';
-import { timestamp } from '@lib/shared';
-import { InstrumentSubscriptionEvent, Store } from '@lib/store';
-
-export interface BacktesterOptions extends PaperOptions {
-  from: timestamp;
-  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;
-
-  constructor(
-    readonly decoratedAdapter: Adapter,
-    readonly streamer: BacktesterStreamer,
-    readonly store: Store
-  ) {
-    super(streamer.getTimeProvider());
-  }
-
-  async awake(): Promise<void> {
-    await this.decoratedAdapter.awake();
-  }
-
-  dispose(): Promise<void> {
-    return this.decoratedAdapter.dispose();
-  }
-
-  async subscribe(instruments: InstrumentSelector[]): Promise<void> {
-    instruments.forEach(it => {
-      this.streamer.subscribe(it);
-    });
-
-    this.store.dispatch(
-      ...instruments.map(
-        it => new InstrumentSubscriptionEvent(this.timestamp(), it, true)
-      )
-    );
-  }
-
-  account(): Promise<void> {
-    return this.decoratedAdapter.account();
-  }
-
-  open(order: Order): Promise<void> {
-    return this.decoratedAdapter.open(order);
-  }
-
-  cancel(order: Order): Promise<void> {
-    return this.decoratedAdapter.cancel(order);
-  }
-
-  async history(
-    instrument: InstrumentSelector,
-    timeframe: number,
-    length: number
-  ): Promise<Ohlc[]> {
-    this.streamer.stop();
-
-    const response = await this.decoratedAdapter.history(instrument, timeframe, length);
-
-    this.streamer.tryContinue();
-
-    return response;
-  }
-
-  feed(
-    instrument: InstrumentSelector,
-    from: timestamp,
-    to: timestamp,
-    callback: FeedAsyncCallback
-  ): Promise<void> {
-    return this.decoratedAdapter.feed(instrument, from, to, callback);
-  }
-
-  createPaperEngine(adapter: PaperAdapter): PaperEngine {
-    return this.decoratedAdapter.createPaperEngine(adapter);
-  }
-}

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

@@ -1,44 +0,0 @@
-import { BacktesterCursor } from '@lib/adapter';
-import { instrumentOf } from '@lib/domain';
-import { d } from '@lib/shared';
-import { Feed, InMemoryStorage } from '@lib/storage';
-import { TradePatchEvent } from '@lib/store';
-
-describe(BacktesterCursor.name, () => {
-  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([
-      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()).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()).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()).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,47 +0,0 @@
-import { BacktestPageNotEmpty } from '@lib/adapter';
-import { InstrumentSelector } from '@lib/domain';
-import { timestamp } from '@lib/shared';
-import { Feed, StorageEvent } from '@lib/storage';
-
-export class BacktesterCursor {
-  private page = new Array<StorageEvent>();
-  private pageIndex = 0;
-  completed = false;
-
-  get size(): number {
-    return this.page.length - this.pageIndex;
-  }
-
-  constructor(readonly instrument: InstrumentSelector, private readonly feed: Feed) {}
-
-  peek(): StorageEvent | undefined {
-    if (!this.page) {
-      return undefined;
-    }
-
-    return this.page[this.pageIndex];
-  }
-
-  dequeue(): StorageEvent {
-    return this.page[this.pageIndex++];
-  }
-
-  async fetchNextPage(from: timestamp, to: number): Promise<void> {
-    if (this.completed) {
-      return;
-    }
-
-    if (this.size > 0) {
-      throw new BacktestPageNotEmpty();
-    }
-
-    this.pageIndex = 0;
-    this.page = await this.feed.query(this.instrument, {
-      from,
-      to,
-      count: 10000
-    });
-
-    this.completed = this.page.length == 0;
-  }
-}

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

@@ -1,60 +0,0 @@
-import { BacktesterStreamer } from '@lib/adapter';
-import { Asset, Commission, Instrument } from '@lib/domain';
-import { d } from '@lib/shared';
-import { Feed, InMemoryStorage } from '@lib/storage';
-import { Store, TradePatchEvent } from '@lib/store';
-
-describe(BacktesterStreamer.name, () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('btc', 'binance', 8),
-    new Asset('usdt', 'binance', 2),
-    'binance:btc-usdt',
-    Commission.Zero
-  );
-
-  test('should repeat specific events', done => {
-    const feed = new Feed(new InMemoryStorage());
-    const store = new Store();
-
-    store.snapshot.universe.instrument.upsert(instrument);
-    store.snapshot.subscription.instrument.upsert(instrument);
-
-    const streamer = new BacktesterStreamer(
-      store,
-      feed,
-      {
-        from: 0,
-        to: 10
-      },
-      {
-        onBacktestCompleted: () => {
-          const trade = store.snapshot.trade.get(instrument.id) ?? fail();
-
-          expect(trade.timestamp).toEqual(8);
-          expect(trade.rate).toEqual(d(8));
-          expect(trade.quantity).toEqual(d(8));
-          expect(store.snapshot.timestamp).toEqual(8);
-
-          done();
-        }
-      }
-    );
-
-    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)
-      ])
-      .then(() => {
-        streamer.subscribe(instrument);
-        streamer.tryContinue();
-      });
-  });
-});

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

@@ -1,158 +0,0 @@
-import {
-  AdapterTimeProvider,
-  BacktesterCursor,
-  InvalidEventSequenceError,
-  MissingPeriodParametersError
-} from '@lib/adapter';
-import { InstrumentSelector } from '@lib/domain';
-import { timestamp } from '@lib/shared';
-import { Feed } from '@lib/storage';
-import { Store } from '@lib/store';
-
-/**
- * Listen to backtest session events.
- */
-export interface BacktesterListener {
-  /**
-   * Called once when backtest started.
-   */
-  onBacktestStarted?(streamer: BacktesterStreamer): void;
-
-  /**
-   * Called every time when backtest progress updated.
-   */
-  onBacktestUpdated?(streamer: BacktesterStreamer): void;
-
-  /**
-   * Called once when backtest completed.
-   */
-  onBacktestCompleted?(streamer: BacktesterStreamer): void;
-}
-
-export class BacktesterStreamer {
-  private sequenceUpdateBatch = 10000;
-  private cursor: Record<string, BacktesterCursor> = {};
-  private stopAcquire = 1;
-
-  timestamp: timestamp;
-  sequence = 0;
-
-  constructor(
-    private readonly store: Store,
-    private readonly feed: Feed,
-    private readonly period: { from: number; to: number },
-    private readonly listener?: BacktesterListener
-  ) {
-    if (period.from == undefined || period.to == undefined) {
-      throw new MissingPeriodParametersError();
-    }
-
-    this.timestamp = period.from;
-  }
-
-  getTimeProvider(): AdapterTimeProvider {
-    const provider = {
-      timestamp: () => this.timestamp
-    };
-
-    return provider;
-  }
-
-  subscribe(instrument: InstrumentSelector) {
-    if (instrument.id in this.cursor) {
-      return;
-    }
-
-    const cursor = new BacktesterCursor(instrument, this.feed);
-
-    this.cursor[instrument.id] = cursor;
-  }
-
-  /**
-   * Increments stop counter.
-   */
-  stop() {
-    this.stopAcquire++;
-  }
-
-  /**
-   * Decreases stop counter and continues execution if no more stops requested.
-   */
-  tryContinue() {
-    if (this.stopAcquire == 0) {
-      return;
-    }
-
-    this.stopAcquire = Math.max(0, this.stopAcquire - 1);
-
-    if (this.stopAcquire != 0) {
-      return;
-    }
-
-    if (this.sequence == 0) {
-      if (this.listener?.onBacktestStarted) {
-        this.listener.onBacktestStarted(this);
-      }
-    }
-
-    const next = async () => {
-      if (await this.processNext()) {
-        if (this.sequence % this.sequenceUpdateBatch == 0) {
-          if (this.listener?.onBacktestUpdated) {
-            this.listener.onBacktestUpdated(this);
-          }
-        }
-
-        if (this.stopAcquire === 0) {
-          setImmediate(next);
-        }
-      } else {
-        if (this.listener?.onBacktestCompleted) {
-          this.listener.onBacktestCompleted(this);
-        }
-      }
-    };
-
-    next();
-  }
-
-  private async processNext(): Promise<boolean> {
-    const cursor = await this.current(this.timestamp, this.period.to);
-    if (!cursor) {
-      return false;
-    }
-
-    const event = cursor.peek();
-
-    if (!event) {
-      return false;
-    }
-
-    this.timestamp = event.timestamp;
-    this.sequence++;
-
-    this.store.dispatch(event);
-
-    if (cursor.dequeue().timestamp != event.timestamp) {
-      throw new InvalidEventSequenceError();
-    }
-
-    return true;
-  }
-
-  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);
-      }
-    }
-
-    return Object.values(this.cursor)
-      .filter(it => it !== undefined)
-      .sort((lhs, rhs) => (lhs?.peek()?.timestamp ?? 0) - (rhs?.peek()?.timestamp ?? 0))
-      .find(() => true);
-  }
-}

package/src/adapter/backtester/error.ts

@@ -1,11 +0,0 @@
-export class MissingPeriodParametersError extends Error {
-  constructor() {
-    super('invalid backtest options, please provide from and to period.');
-  }
-}
-
-export class InvalidEventSequenceError extends Error {
-  constructor() {
-    super('invalid event to consume');
-  }
-}

package/src/adapter/backtester/index.ts

@@ -1,4 +0,0 @@
-export * from '@lib/adapter/backtester/backtester-adapter';
-export * from '@lib/adapter/backtester/backtester-streamer';
-export * from '@lib/adapter/backtester/backtester-cursor';
-export * from '@lib/adapter/backtester/error';

package/src/adapter/error.ts

@@ -1,19 +0,0 @@
-export class AdapterNotFoundError extends Error {
-  constructor(adapterName: string) {
-    super(
-      `Unknown adapter: ${adapterName}. You should provide adapter in session descriptor.`
-    );
-  }
-}
-
-export class NoPaperEngineProvidedError extends Error {
-  constructor() {
-    super('No paper engine provided.');
-  }
-}
-
-export class BacktestPageNotEmpty extends Error {
-  constructor() {
-    super('Backtest page is not empty');
-  }
-}

package/src/adapter/index.ts

@@ -1,5 +0,0 @@
-export * from '@lib/adapter/adapter';
-export * from '@lib/adapter/adapter-aggregate';
-export * from '@lib/adapter/backtester';
-export * from '@lib/adapter/paper';
-export * from '@lib/adapter/error';

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

@@ -1,110 +0,0 @@
-import { PaperEngine } from '@lib/adapter';
-import { Asset, Commission, commissionPercentOf, Instrument, Order } from '@lib/domain';
-import { d, now } from '@lib/shared';
-import {
-  BalancePatchEvent,
-  InstrumentPatchEvent,
-  InstrumentSubscriptionEvent,
-  OrderbookPatchEvent,
-  Store
-} from '@lib/store';
-
-describe('PaperEngine', () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('btc', 'binance', 8),
-    new Asset('usdt', 'binance', 2),
-    'binance:btc-usdt',
-    Commission.Zero
-  );
-
-  const commission = commissionPercentOf({
-    maker: d(0.1),
-    taker: d(0.1)
-  });
-
-  test('should open a new buy market order', () => {
-    const store = new Store();
-    const engine = new PaperEngine(store);
-    const order = new Order(0, '1', instrument, d(1.0), 0);
-
-    store.dispatch(
-      new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
-      new BalancePatchEvent(instrument.base, d(1), d.Zero, now()),
-      new BalancePatchEvent(instrument.quote, d(1000), d.Zero, now())
-    );
-
-    engine.open(order);
-
-    const pendingOrder = store.snapshot.order.get(instrument.id)?.get(order.id) ?? fail();
-    const balance = store.snapshot.balance.get(instrument.quote.id) ?? fail();
-
-    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(pendingOrder).toEqual(order);
-    expect(balance.free).toEqual(d.Zero);
-    expect(balance.locked).toEqual(d(1000));
-  });
-
-  test('should open a new sell market order', () => {
-    const store = new Store();
-    const engine = new PaperEngine(store);
-    const order = new Order(0, '1', instrument, d(-0.6), 0);
-
-    store.dispatch(
-      new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
-      new BalancePatchEvent(instrument.base, d(1), d.Zero, now()),
-      new BalancePatchEvent(instrument.quote, d(1000), d.Zero, now())
-    );
-
-    engine.open(order);
-
-    const pendingOrder = store.snapshot.order.get(instrument.id)?.get(order.id) ?? fail();
-    const balance = store.snapshot.balance.get(instrument.base.id) ?? fail();
-
-    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(pendingOrder).toEqual(order);
-    expect(balance.free).toEqual(d(0.4));
-    expect(balance.locked).toEqual(d(0.6));
-  });
-
-  test('should open and fill a new sell limit order', () => {
-    const store = new Store();
-    const engine = new PaperEngine(store);
-    const order = new Order(0, '1', instrument, d(-0.6), 0, d(100));
-
-    store.dispatch(
-      new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
-      new BalancePatchEvent(instrument.base, d(1), d.Zero, now()),
-      new BalancePatchEvent(instrument.quote, d(1000), d.Zero, now()),
-      new InstrumentSubscriptionEvent(now(), instrument, true)
-    );
-
-    engine.open(order);
-
-    const pendingOrder = store.snapshot.order.get(instrument.id)?.get(order.id) ?? fail();
-    const baseBalance = store.snapshot.balance.get(instrument.base.id) ?? fail();
-
-    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(pendingOrder.state).toEqual('PENDING');
-    expect(baseBalance.free).toEqual(d(0.4));
-    expect(baseBalance.locked).toEqual(d(0.6));
-
-    store.dispatch(
-      new OrderbookPatchEvent(
-        instrument,
-        { rate: d(102), quantity: d(1), next: undefined },
-        { rate: d(101), quantity: d(1), next: undefined },
-        now()
-      )
-    );
-
-    const quoteBalance = store.snapshot.balance.get(instrument.quote.id) ?? fail();
-
-    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(pendingOrder.state).toEqual('FILLED');
-    expect(baseBalance.free).toEqual(d(0.4));
-    expect(baseBalance.locked).toEqual(d(0.6));
-    expect(quoteBalance.free).toEqual(d(1000));
-    expect(quoteBalance.locked).toEqual(d.Zero);
-  });
-});

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

@@ -1,136 +0,0 @@
-import { tap } from 'rxjs';
-
-import { Order, Orderbook, Trade } from '@lib/domain';
-import { d, decimal } from '@lib/shared';
-import {
-  InstrumentNotSupportedError,
-  OrderCanceledEvent,
-  OrderCancelingEvent,
-  OrderFilledEvent,
-  OrderNewEvent,
-  OrderPendingEvent,
-  OrderRejectedEvent,
-  Store
-} from '@lib/store';
-
-export class PaperEngine {
-  constructor(private readonly store: Store) {
-    store.changes$
-      .pipe(
-        tap(it => {
-          if (it.type === Orderbook.type) {
-            this.onOrderbook(it as Orderbook);
-          } else if (it.type === Trade.type) {
-            this.onTrade(it as Trade);
-          }
-        })
-      )
-      .subscribe();
-  }
-
-  public open(order: Order) {
-    const { timestamp } = this.store.snapshot;
-
-    try {
-      this.store.dispatch(new OrderNewEvent(order, timestamp));
-
-      this.store.dispatch(new OrderPendingEvent(order.id, order.instrument, timestamp));
-    } catch (error) {
-      this.store.dispatch(new OrderRejectedEvent(order.id, order.instrument, timestamp));
-    }
-  }
-
-  public cancel(order: Order) {
-    const { timestamp } = this.store.snapshot;
-
-    this.store.dispatch(new OrderCancelingEvent(order.id, order.instrument, timestamp));
-
-    this.store.dispatch(new OrderCanceledEvent(order.id, order.instrument, timestamp));
-  }
-
-  private onOrderbook(orderbook: Orderbook) {
-    const orders = this.store.snapshot.order.get(orderbook.instrument.id);
-    if (!orders) {
-      return;
-    }
-
-    orders.asReadonlyArray().forEach(it => {
-      if (it.state != 'PENDING') {
-        return;
-      }
-
-      if (it.rate) {
-        if (it.quantity.greaterThan(0) && it.rate.greaterThan(orderbook.asks.rate)) {
-          this.completeOrder(it, orderbook.asks.rate);
-        } else if (it.quantity.lessThan(0) && it.rate.lessThan(orderbook.bids.rate)) {
-          this.completeOrder(it, orderbook.bids.rate);
-        }
-      } else {
-        if (it.quantity.greaterThan(0)) {
-          this.completeOrder(it, orderbook.asks.rate);
-        } else if (it.quantity.lessThan(0)) {
-          this.completeOrder(it, orderbook.bids.rate);
-        }
-      }
-    });
-  }
-
-  private onTrade(trade: Trade) {
-    const orders = this.store.snapshot.order.get(trade.instrument.id);
-    if (!orders) {
-      return;
-    }
-
-    orders.asReadonlyArray().forEach(it => {
-      if (it.state != 'PENDING') {
-        return;
-      }
-
-      if (it.rate) {
-        if (it.quantity.greaterThan(0) && it.rate.greaterThan(trade.rate)) {
-          this.completeOrder(it, trade.rate);
-        } else if (it.quantity.lessThan(0) && it.rate.lessThan(trade.rate)) {
-          this.completeOrder(it, trade.rate);
-        }
-      } else {
-        this.completeOrder(it, trade.rate);
-      }
-    });
-  }
-
-  private completeOrder(order: Order, averageExecutionRate: decimal) {
-    const { timestamp } = this.store.snapshot;
-
-    const instrument = this.store.snapshot.universe.instrument.get(order.instrument.id);
-    if (!instrument) {
-      throw new InstrumentNotSupportedError(order.instrument);
-    }
-
-    const transacted = {
-      base: d.Zero,
-      quote: d.Zero
-    };
-
-    const qty = order.quantity.abs();
-
-    if (order.quantity.greaterThan(0)) {
-      transacted.base = transacted.base.plus(
-        instrument.base.floor(instrument.commission.applyMakerFee(qty))
-      );
-      transacted.quote = transacted.quote.minus(
-        instrument.quote.floor(averageExecutionRate.mul(qty))
-      );
-    } else if (order.quantity.lessThan(0)) {
-      transacted.base = transacted.base.minus(instrument.base.floor(qty));
-      transacted.quote = transacted.quote.plus(
-        instrument.quote.floor(
-          instrument.commission.applyMakerFee(averageExecutionRate.mul(qty))
-        )
-      );
-    }
-
-    this.store.dispatch(
-      new OrderFilledEvent(order.id, order.instrument, averageExecutionRate, timestamp)
-    );
-  }
-}