@quantform/core 0.5.13 → 0.5.23

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

@@ -1,21 +1,22 @@
-import { Asset, Instrument, Timeframe } from '../../domain';
+import { Asset, Instrument } from '../../domain';
+import { d } from '../../shared';
 import { Feed, InMemoryStorage } from '../../storage';
-import { CandleEvent, Store } from '../../store';
+import { Store, TradePatchEvent } 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,11 +27,11 @@ 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);
-          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 +40,15 @@ 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)
+      .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

@@ -2,6 +2,7 @@ import { InstrumentSelector } from '../../domain';
 import { timestamp } from '../../shared';
 import { Feed } from '../../storage';
 import { Store } from '../../store';
+import { AdapterTimeProvider } from '../adapter';
 import { BacktesterCursor } from './backtester-cursor';
 
 /**
@@ -45,14 +46,22 @@ export class BacktesterStreamer {
     this.timestamp = period.from;
   }
 
+  getTimeProvider(): AdapterTimeProvider {
+    const provider = {
+      timestamp: () => this.timestamp
+    };
+
+    return provider;
+  }
+
   subscribe(instrument: InstrumentSelector) {
-    if (instrument.toString() in this.cursor) {
+    if (instrument.id in this.cursor) {
       return;
     }
 
     const cursor = new BacktesterCursor(instrument, this.feed);
 
-    this.cursor[instrument.toString()] = cursor;
+    this.cursor[instrument.id] = cursor;
   }
 
   /**
@@ -65,7 +74,7 @@ export class BacktesterStreamer {
   /**
    * Decreases stop counter and continues execution if no more stops requested.
    */
-  async tryContinue(): Promise<void> {
+  tryContinue() {
     if (this.stopAcquire == 0) {
       return;
     }
@@ -82,21 +91,25 @@ export class BacktesterStreamer {
       }
     }
 
-    while (await this.processNext()) {
-      if (this.sequence % this.sequenceUpdateBatch == 0) {
-        if (this.listener.onBacktestUpdated) {
-          this.listener.onBacktestUpdated(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) {
-        return;
+        if (this.stopAcquire === 0) {
+          setImmediate(next);
+        }
+      } else {
+        if (this.listener.onBacktestCompleted) {
+          this.listener.onBacktestCompleted(this);
+        }
       }
-    }
+    };
 
-    if (this.listener.onBacktestCompleted) {
-      this.listener.onBacktestCompleted(this);
-    }
+    next();
   }
 
   private async processNext(): Promise<boolean> {
@@ -127,7 +140,7 @@ export class BacktesterStreamer {
     }
 
     return Object.values(this.cursor)
-      .filter(it => it.peek() != null)
+      .filter(it => it.peek() != undefined)
       .sort((lhs, rhs) => lhs.peek().timestamp - rhs.peek().timestamp)
       .find(() => true);
   }

package/src/adapter/error.ts

@@ -0,0 +1,9 @@
+export function adapterNotFoundError(adapterName: string) {
+  return new Error(
+    `Unknown adapter: ${adapterName}. You should provide adapter in session descriptor.`
+  );
+}
+
+export function backtestPageNotEmpty() {
+  return new Error('Backtest page is not empty');
+}

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

@@ -0,0 +1,99 @@
+import { Asset, commissionPercentOf, Instrument, Order } from '../../../domain';
+import { d, now } from '../../../shared';
+import {
+  BalancePatchEvent,
+  InstrumentPatchEvent,
+  InstrumentSubscriptionEvent,
+  OrderbookPatchEvent,
+  Store
+} from '../../../store';
+import { PaperEngine } from './paper-engine';
+
+describe('PaperEngine', () => {
+  const instrument = new Instrument(
+    new Asset('btc', 'binance', 8),
+    new Asset('usdt', 'binance', 2),
+    'binance:btc-usdt'
+  );
+
+  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 = Order.market(instrument, d(1.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);
+
+    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
+    expect(store.snapshot.order.get(instrument.id).get(order.id)).toEqual(order);
+    expect(store.snapshot.balance.get(instrument.quote.id).free).toEqual(d.Zero);
+    expect(store.snapshot.balance.get(instrument.quote.id).locked).toEqual(d(1000));
+  });
+
+  test('should open a new sell market order', () => {
+    const store = new Store();
+    const engine = new PaperEngine(store);
+    const order = Order.market(instrument, d(-0.6));
+
+    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);
+
+    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
+    expect(store.snapshot.order.get(instrument.id).get(order.id)).toEqual(order);
+    expect(store.snapshot.balance.get(instrument.base.id).free).toEqual(d(0.4));
+    expect(store.snapshot.balance.get(instrument.base.id).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 = Order.limit(instrument, d(-0.6), 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);
+
+    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
+    expect(store.snapshot.order.get(instrument.id).get(order.id).state).toEqual(
+      'PENDING'
+    );
+    expect(store.snapshot.balance.get(instrument.base.id).free).toEqual(d(0.4));
+    expect(store.snapshot.balance.get(instrument.base.id).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()
+      )
+    );
+
+    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
+    expect(store.snapshot.order.get(instrument.id).get(order.id).state).toEqual('FILLED');
+    expect(store.snapshot.balance.get(instrument.base.id).free).toEqual(d(0.4));
+    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(d.Zero);
+    expect(store.snapshot.balance.get(instrument.quote.id).free).toEqual(d(1060.53));
+    expect(store.snapshot.balance.get(instrument.quote.id).locked).toEqual(d.Zero);
+  });
+});

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

@@ -0,0 +1,142 @@
+import { tap } from 'rxjs';
+
+import { Order, Orderbook, Trade } from '../../../domain';
+import { d, decimal } from '../../../shared';
+import {
+  BalanceLockOrderEvent,
+  BalanceTransactEvent,
+  BalanceUnlockOrderEvent,
+  OrderCanceledEvent,
+  OrderCancelingEvent,
+  OrderFilledEvent,
+  OrderNewEvent,
+  OrderPendingEvent,
+  OrderRejectedEvent,
+  Store
+} from '../../../store';
+
+export class PaperEngine {
+  constructor(private readonly store: Store) {
+    store.changes$
+      .pipe(
+        tap(it => {
+          if (it instanceof Orderbook) {
+            this.onOrderbook(it);
+          } else if (it instanceof Trade) {
+            this.onTrade(it);
+          }
+        })
+      )
+      .subscribe();
+  }
+
+  public open(order: Order) {
+    const { timestamp } = this.store.snapshot;
+
+    try {
+      this.store.dispatch(
+        new OrderNewEvent(order, timestamp),
+        new BalanceLockOrderEvent(order.id, order.instrument, timestamp)
+      );
+
+      this.store.dispatch(new OrderPendingEvent(order.id, order.instrument, timestamp));
+    } catch (error) {
+      this.store.dispatch(
+        new BalanceUnlockOrderEvent(order.id, order.instrument, timestamp),
+        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 BalanceUnlockOrderEvent(order.id, order.instrument, timestamp),
+      new OrderCanceledEvent(order.id, order.instrument, timestamp)
+    );
+  }
+
+  private onOrderbook(orderbook: Orderbook) {
+    this.store.snapshot.order
+      .get(orderbook.instrument.id)
+      .asReadonlyArray()
+      .forEach(it => {
+        if (it.state != 'PENDING') {
+          return;
+        }
+
+        if (it.type == 'LIMIT') {
+          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.type == 'MARKET') {
+          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) {
+    this.store.snapshot.order
+      .get(trade.instrument.id)
+      .asReadonlyArray()
+      .forEach(it => {
+        if (it.state != 'PENDING') {
+          return;
+        }
+
+        if (it.type == 'LIMIT') {
+          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 if (it.type == 'MARKET') {
+          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);
+    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 BalanceUnlockOrderEvent(order.id, order.instrument, timestamp),
+      new OrderFilledEvent(order.id, order.instrument, averageExecutionRate, timestamp),
+      new BalanceTransactEvent(instrument.base, transacted.base, timestamp),
+      new BalanceTransactEvent(instrument.quote, transacted.quote, timestamp)
+    );
+  }
+}

package/src/adapter/paper/index.ts

@@ -1,3 +1,2 @@
 export * from './paper-adapter';
-export * from './simulator/paper-margin-simulator';
-export * from './simulator/paper-spot-simulator';
+export * from './engine/paper-engine';

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

@@ -1,39 +1,81 @@
-import { Cache, InMemoryStorage } from '../../storage';
+import { d, timestamp } from '../../shared';
 import { InstrumentPatchEvent, Store } from '../../store';
-import { AdapterContext } from '..';
-import { Adapter } from '../adapter';
-import { Asset, Commission, instrumentOf, Order } from './../../domain';
-import { PaperSpotSimulator } from '.';
+import {
+  Adapter,
+  AdapterTimeProvider,
+  DefaultTimeProvider,
+  FeedAsyncCallback
+} from '../adapter';
+import {
+  Asset,
+  Candle,
+  Commission,
+  instrumentOf,
+  InstrumentSelector,
+  Order
+} from './../../domain';
+import { PaperEngine } from './engine/paper-engine';
 import { PaperAdapter } from './paper-adapter';
-import { PaperSimulator } from './simulator/paper-simulator';
 
 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';
 
   timestamp() {
     return 123;
   }
 
-  async awake(context: AdapterContext): Promise<void> {
-    super.awake(context);
+  constructor(timeProvider: AdapterTimeProvider, private readonly store: Store) {
+    super(timeProvider);
+  }
 
-    context.dispatch(
+  async awake(): Promise<void> {
+    this.store.dispatch(
       new InstrumentPatchEvent(
-        context.timestamp,
+        this.timestamp(),
         new Asset('a', this.name, 8),
         new Asset('b', this.name, 4),
-        new Commission(0.1, 0.1),
+        new Commission(d(0.1), d(0.1)),
         'a-b'
       )
     );
   }
 
-  createPaperSimulator(adapter: PaperAdapter): PaperSimulator {
-    return new PaperSpotSimulator(adapter);
+  createPaperEngine(adapter: PaperAdapter): PaperEngine {
+    return new PaperEngine(adapter.store);
   }
 }
 
-describe('paper adapter tests', () => {
+describe('PaperAdapter', () => {
   const options = {
     balance: {
       ['default:a']: 1000,
@@ -44,7 +86,11 @@ describe('paper adapter tests', () => {
   test('should return wrapped adapter name and timestamp', () => {
     const store = new Store();
 
-    const sut = new PaperAdapter(new DefaultAdapter(), store, options);
+    const sut = new PaperAdapter(
+      new DefaultAdapter(DefaultTimeProvider, store),
+      store,
+      options
+    );
 
     expect(sut.name).toEqual('default');
     expect(sut.timestamp()).toEqual(123);
@@ -52,18 +98,17 @@ describe('paper adapter tests', () => {
 
   test('', async () => {
     const store = new Store();
-    const adapter = new DefaultAdapter();
-    const cache = new Cache(new InMemoryStorage());
+    const adapter = new DefaultAdapter(DefaultTimeProvider, store);
 
     const sut = new PaperAdapter(adapter, store, options);
 
-    await sut.awake(new AdapterContext(sut, store, cache));
+    await sut.awake();
     await sut.account();
 
-    const order = Order.buyMarket(instrumentOf('default:a-b'), 1.0);
+    const order = Order.market(instrumentOf('default:a-b'), d(1.0));
 
     await sut.open(order);
 
-    expect(store.snapshot.order[order.id]).toEqual(order);
+    expect(store.snapshot.order.get(order.instrument.id).get(order.id)).toEqual(order);
   });
 });

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

@@ -1,34 +1,40 @@
 import { assetOf, Candle, InstrumentSelector, Order } from '../../domain';
+import { d, timestamp } from '../../shared';
 import { BalancePatchEvent, Store } from '../../store';
-import { Adapter, AdapterContext } from '..';
-import { FeedQuery, HistoryQuery } from '../adapter';
-import { PaperSimulator } from './simulator/paper-simulator';
+import { Adapter } from '..';
+import { AdapterFactory, FeedAsyncCallback } from '../adapter';
+import { PaperEngine } from './engine/paper-engine';
 
 export interface PaperOptions {
   balance: { [key: string]: number };
 }
 
+export function createPaperAdapterFactory(
+  decoratedAdapterFactory: AdapterFactory,
+  options: PaperOptions
+): AdapterFactory {
+  return (timeProvider, store, cache) =>
+    new PaperAdapter(decoratedAdapterFactory(timeProvider, store, cache), store, options);
+}
+
 export class PaperAdapter extends Adapter {
   readonly name = this.decoratedAdapter.name;
-  readonly simulator: PaperSimulator;
+  private engine: PaperEngine;
 
   constructor(
     readonly decoratedAdapter: Adapter,
     readonly store: Store,
     readonly options: PaperOptions
   ) {
-    super();
-
-    this.simulator = this.createPaperSimulator(this);
+    super({
+      timestamp: () => this.decoratedAdapter.timestamp()
+    });
   }
 
-  timestamp() {
-    return this.decoratedAdapter.timestamp();
-  }
+  async awake(): Promise<void> {
+    this.engine = this.createPaperEngine(this);
 
-  async awake(context: AdapterContext): Promise<void> {
-    await super.awake(context);
-    await this.decoratedAdapter.awake(context);
+    await this.decoratedAdapter.awake();
   }
 
   dispose(): Promise<void> {
@@ -41,47 +47,56 @@ export class PaperAdapter extends Adapter {
 
   async account(): Promise<void> {
     let subscribed = Object.values(this.store.snapshot.subscription.asset).filter(
-      it => it.adapter == this.name
+      it => it.adapterName == this.name
     );
 
     for (const balance in this.options.balance) {
       const asset = assetOf(balance);
 
-      if (asset.adapter != this.name) {
+      if (asset.adapterName != this.name) {
         continue;
       }
 
-      const free = this.options.balance[balance];
+      const free = d(this.options.balance[balance]);
 
-      subscribed = subscribed.filter(it => it.toString() != asset.toString());
+      subscribed = subscribed.filter(it => it.id != asset.id);
 
-      this.store.dispatch(new BalancePatchEvent(asset, free, 0, this.context.timestamp));
+      this.store.dispatch(new BalancePatchEvent(asset, free, d.Zero, this.timestamp()));
     }
 
     for (const missingAsset of subscribed) {
       this.store.dispatch(
-        new BalancePatchEvent(missingAsset, 0, 0, this.context.timestamp)
+        new BalancePatchEvent(missingAsset, d.Zero, d.Zero, this.timestamp())
       );
     }
   }
 
   async open(order: Order): Promise<void> {
-    this.simulator.open(order);
+    this.engine.open(order);
   }
 
   async cancel(order: Order): Promise<void> {
-    this.simulator.cancel(order);
+    this.engine.cancel(order);
   }
 
-  history(query: HistoryQuery): Promise<Candle[]> {
-    return this.decoratedAdapter.history(query);
+  history(
+    instrument: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]> {
+    return this.decoratedAdapter.history(instrument, timeframe, length);
   }
 
-  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);
   }
 }