@quantform/core 0.5.14 → 0.5.15

package/src/store/store-position.event.ts

@@ -0,0 +1,102 @@
+import { Instrument, Position, PositionMode } from '../domain';
+import { timestamp } from '../shared';
+import { StoreEvent } from './store.event';
+import { State, StateChangeTracker } from './store-state';
+
+export class PositionLoadEvent implements StoreEvent {
+  constructor(readonly position: Position, readonly timestamp: timestamp) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    if (!state.subscription.instrument.get(this.position.instrument.id)) {
+      throw new Error(
+        `Trying to patch unsubscribed instrument: ${this.position.instrument.id}`
+      );
+    }
+
+    this.position.timestamp = this.timestamp;
+
+    const balance = state.balance.get(this.position.instrument.quote.id);
+    const orderbook = state.orderbook.get(this.position.instrument.id);
+
+    balance.position[this.position.id] = this.position;
+
+    if (orderbook) {
+      const rate =
+        this.position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
+
+      this.position.calculateEstimatedUnrealizedPnL(rate);
+    }
+  }
+}
+
+export class PositionPatchEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: Instrument,
+    readonly rate: number,
+    readonly size: number,
+    readonly leverage: number,
+    readonly mode: PositionMode,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    if (!state.subscription.instrument.get(this.instrument.id)) {
+      throw new Error(`Trying to patch unsubscribed instrument: ${this.instrument.id}`);
+    }
+
+    const balance = state.balance.get(this.instrument.quote.id);
+    const orderbook = state.orderbook.get(this.instrument.id);
+
+    let position = balance.position[this.id];
+
+    if (this.size == 0) {
+      if (position) {
+        position.averageExecutionRate = this.instrument.quote.fixed(this.rate);
+        position.size = this.instrument.base.fixed(this.size);
+        position.leverage = this.leverage;
+
+        delete balance.position[this.id];
+
+        if (orderbook) {
+          const rate = position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
+
+          position.calculateEstimatedUnrealizedPnL(rate);
+        }
+
+        changes.commit(position);
+        changes.commit(balance);
+      }
+    }
+
+    const size = (position.size = this.instrument.base.fixed(this.size));
+    const averageExecutionRate = (position.averageExecutionRate =
+      this.instrument.quote.fixed(this.rate));
+
+    if (!position) {
+      position = new Position(
+        this.id,
+        this.instrument,
+        this.mode,
+        averageExecutionRate,
+        size,
+        this.leverage
+      );
+
+      balance.position[this.id] = position;
+    } else {
+      position.averageExecutionRate = averageExecutionRate;
+      position.size = size;
+      position.leverage = this.leverage;
+    }
+
+    if (orderbook) {
+      const rate = position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
+
+      position.calculateEstimatedUnrealizedPnL(rate);
+    }
+
+    changes.commit(position);
+    changes.commit(balance);
+  }
+}

package/src/store/store-state.ts

@@ -0,0 +1,48 @@
+import {
+  Asset,
+  AssetSelector,
+  Balance,
+  Component,
+  Instrument,
+  InstrumentSelector,
+  Order,
+  Orderbook,
+  Trade
+} from '../domain';
+import { Set, timestamp } from '../shared';
+
+export interface StateChangeTracker {
+  commit(component: Component);
+  commitPendingChanges();
+}
+
+export class InnerSet<T extends { id: string }> extends Set<T> {
+  constructor(public readonly id: string, values?: ReadonlyArray<T>) {
+    super(values);
+  }
+}
+
+export class State {
+  timestamp: timestamp;
+
+  universe: {
+    asset: Set<Asset>;
+    instrument: Set<Instrument>;
+  } = {
+    asset: new Set<Asset>(),
+    instrument: new Set<Instrument>()
+  };
+
+  subscription: {
+    asset: Set<AssetSelector>;
+    instrument: Set<InstrumentSelector>;
+  } = {
+    asset: new Set<AssetSelector>(),
+    instrument: new Set<InstrumentSelector>()
+  };
+
+  trade: Set<Trade> = new Set<Trade>();
+  orderbook: Set<Orderbook> = new Set<Orderbook>();
+  balance: Set<Balance> = new Set<Balance>();
+  order: Set<InnerSet<Order>> = new Set<InnerSet<Order>>();
+}

package/src/store/{event/store-trade.event.spec.ts → store-trade.event.spec.ts}

@@ -1,6 +1,6 @@
-import { Asset, Instrument } from '../../domain';
-import { now } from '../../shared';
 import { Store } from '..';
+import { Asset, Instrument } from '../domain';
+import { now } from '../shared';
 import { TradePatchEvent } from '.';
 
 const instrument = new Instrument(
@@ -9,20 +9,20 @@ const instrument = new Instrument(
   'binance:btc-usdt'
 );
 
-describe('trade patch event tests', () => {
+describe('TradePatchEvent', () => {
   test('should create a new trade object and patch a store', () => {
     const timestamp = now();
     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);
 
     store.dispatch(new TradePatchEvent(instrument, 1000, 0.1, timestamp));
 
-    const trade = store.snapshot.trade[instrument.toString()];
+    const trade = store.snapshot.trade.get(instrument.id);
 
     expect(trade.timestamp).toEqual(timestamp);
-    expect(trade.instrument.toString()).toEqual(trade.instrument.toString());
+    expect(trade.instrument.id).toEqual(trade.instrument.id);
     expect(trade.rate).toEqual(1000);
     expect(trade.quantity).toEqual(0.1);
     expect(store.snapshot.timestamp).toEqual(timestamp);
@@ -30,19 +30,19 @@ describe('trade patch event tests', () => {
 
   test('should use the existing instance of trade when patching a store', () => {
     const store = new Store();
+    const timestamp = now();
 
-    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);
 
-    store.dispatch(new TradePatchEvent(instrument, 1000, 0.1, now()));
+    store.dispatch(new TradePatchEvent(instrument, 1000, 0.1, timestamp));
 
-    const timestamp = now();
-    const trade = store.snapshot.trade[instrument.toString()];
+    const trade = store.snapshot.trade.get(instrument.id);
 
-    store.dispatch(new TradePatchEvent(instrument, 2000, 0.2, now()));
+    store.dispatch(new TradePatchEvent(instrument, 2000, 0.2, timestamp));
 
     expect(trade.timestamp).toEqual(timestamp);
-    expect(trade.instrument.toString()).toEqual(instrument.toString());
+    expect(trade.instrument.id).toEqual(instrument.id);
     expect(trade.rate).toEqual(2000);
     expect(trade.quantity).toEqual(0.2);
     expect(store.snapshot.timestamp).toEqual(timestamp);

package/src/store/store-trade.event.ts

@@ -0,0 +1,36 @@
+import { InstrumentSelector, Trade } from '../domain';
+import { timestamp } from '../shared';
+import { StoreEvent } from './store.event';
+import { State, StateChangeTracker } from './store-state';
+
+/**
+ * Patches a store with specific event @see TradePatchEvent
+ * If there is no specific @see Trade in store, it will create a new one.
+ */
+export class TradePatchEvent implements StoreEvent {
+  constructor(
+    readonly instrument: InstrumentSelector,
+    readonly rate: number,
+    readonly quantity: number,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    if (!state.subscription.instrument.get(this.instrument.id)) {
+      throw new Error(`Trying to patch unsubscribed instrument: ${this.instrument.id}`);
+    }
+
+    const trade = state.trade.tryGetOrSet(
+      this.instrument.id,
+      () => new Trade(state.universe.instrument.get(this.instrument.id))
+    );
+
+    state.timestamp = this.timestamp;
+
+    trade.timestamp = this.timestamp;
+    trade.rate = trade.instrument.quote.fixed(this.rate);
+    trade.quantity = trade.instrument.base.fixed(this.quantity);
+
+    changes.commit(trade);
+  }
+}

package/src/store/store.event.ts

@@ -0,0 +1,8 @@
+import { timestamp } from '../shared';
+import { State, StateChangeTracker } from './store-state';
+
+export interface StoreEvent {
+  timestamp: timestamp;
+
+  handle(state: State, changes: StateChangeTracker): void;
+}

package/src/store/store.spec.ts

@@ -0,0 +1,180 @@
+import { withLatestFrom } from 'rxjs';
+
+import { Asset, balance, Instrument, Order, order } from '../domain';
+import { now } from '../shared';
+import { Store } from './store';
+import { BalanceTransactEvent } from './store-balance.event';
+import {
+  OrderCanceledEvent,
+  OrderCancelingEvent,
+  OrderFilledEvent,
+  OrderLoadEvent,
+  OrderNewEvent,
+  OrderPendingEvent
+} from './store-order.event';
+
+const instrument = new Instrument(
+  new Asset('abc', 'xyz', 4),
+  new Asset('def', 'xyz', 4),
+  'abc-def'
+);
+
+describe('Store', () => {
+  let store: Store;
+
+  beforeEach(() => {
+    store = new Store();
+  });
+
+  test('should load an existing order and not pipe a changes', () => {
+    let hasUpdatedOrder = false;
+
+    store.changes$.pipe(order(instrument)).subscribe({
+      next: () => {
+        hasUpdatedOrder = true;
+      }
+    });
+
+    store.dispatch(new OrderLoadEvent(Order.market(instrument, 10), now()));
+
+    expect(hasUpdatedOrder).toBe(false);
+  });
+
+  test('should create a new order and pipe a changes', () => {
+    let hasUpdatedOrder = false;
+
+    store.changes$.pipe(order(instrument)).subscribe({
+      next: () => {
+        hasUpdatedOrder = true;
+      }
+    });
+
+    store.dispatch(new OrderNewEvent(Order.market(instrument, 10), now()));
+
+    expect(hasUpdatedOrder).toBe(true);
+  });
+
+  test('should transition order state from new to pending', () => {
+    const states = ['NEW', 'PENDING'].reverse();
+
+    store.changes$.pipe(order(instrument)).subscribe({
+      next: it => {
+        expect(it.state).toBe(states.pop());
+      }
+    });
+
+    const buyOrder = Order.market(instrument, 10);
+
+    store.dispatch(new OrderNewEvent(buyOrder, now()));
+    store.dispatch(new OrderPendingEvent(buyOrder.id, instrument, now()));
+
+    expect(buyOrder.state).toBe('PENDING');
+    expect(states.length).toBe(0);
+  });
+
+  test('should transition order state from new to filled', () => {
+    const states = ['NEW', 'PENDING', 'FILLED'].reverse();
+
+    store.changes$.pipe(order(instrument)).subscribe({
+      next: it => {
+        expect(it.state).toBe(states.pop());
+      }
+    });
+
+    const buyOrder = Order.market(instrument, 10);
+
+    store.dispatch(new OrderNewEvent(buyOrder, now()));
+    store.dispatch(new OrderPendingEvent(buyOrder.id, instrument, now()));
+    store.dispatch(new OrderFilledEvent(buyOrder.id, instrument, 44, now()));
+
+    expect(buyOrder.state).toBe('FILLED');
+    expect(buyOrder.averageExecutionRate).toBe(44);
+    expect(states.length).toBe(0);
+  });
+
+  test('should transition order state from new to canceled', () => {
+    const states = ['NEW', 'PENDING', 'CANCELING', 'CANCELED'].reverse();
+
+    store.changes$.pipe(order(instrument)).subscribe({
+      next: it => {
+        expect(it.state).toBe(states.pop());
+      }
+    });
+
+    const buyOrder = Order.market(instrument, 10);
+
+    store.dispatch(new OrderNewEvent(buyOrder, now()));
+    store.dispatch(new OrderPendingEvent(buyOrder.id, instrument, now()));
+    store.dispatch(new OrderCancelingEvent(buyOrder.id, instrument, now()));
+    store.dispatch(new OrderCanceledEvent(buyOrder.id, instrument, now()));
+
+    expect(buyOrder.state).toBe('CANCELED');
+    expect(states.length).toBe(0);
+  });
+
+  test('should patch balance with order and pipe changes once', done => {
+    store.snapshot.universe.instrument.upsert(instrument);
+    store.snapshot.universe.asset.upsert(instrument.quote);
+
+    store.changes$
+      .pipe(
+        balance(instrument.quote, store.snapshot),
+        withLatestFrom(store.changes$.pipe(order(instrument)))
+      )
+      .subscribe({
+        next: ([balance, order]) => {
+          expect(balance.free).toBe(10);
+          expect(order.state).toBe('PENDING');
+
+          done();
+        }
+      });
+
+    const buyOrder = Order.market(instrument, 10);
+
+    store.dispatch(
+      new OrderNewEvent(buyOrder, now()),
+      new OrderPendingEvent(buyOrder.id, instrument, now()),
+      new BalanceTransactEvent(instrument.quote, 10, now())
+    );
+  });
+
+  test('should pipe balance and order changes', done => {
+    store.snapshot.universe.instrument.upsert(instrument);
+    store.snapshot.universe.asset.upsert(instrument.quote);
+
+    let counter = 2;
+
+    store.changes$.pipe(balance(instrument.quote, store.snapshot)).subscribe({
+      next: it => {
+        counter--;
+
+        expect(it.free).toBe(10);
+
+        if (!counter) {
+          done();
+        }
+      }
+    });
+
+    store.changes$.pipe(order(instrument)).subscribe({
+      next: it => {
+        counter--;
+
+        expect(it.state).toBe('PENDING');
+
+        if (!counter) {
+          done();
+        }
+      }
+    });
+
+    const buyOrder = Order.market(instrument, 10);
+
+    store.dispatch(
+      new OrderNewEvent(buyOrder, now()),
+      new OrderPendingEvent(buyOrder.id, instrument, now()),
+      new BalanceTransactEvent(instrument.quote, 10, now())
+    );
+  });
+});

package/src/store/store.ts

@@ -1,235 +1,37 @@
-import { BehaviorSubject, Observable, Subject } from 'rxjs';
-import { Set } from 'typescript-collections';
+import { Observable, Subject } from 'rxjs';
 
 import { Component } from '../domain';
-import { handler, Topic } from '../shared/topic';
-import {
-  BalanceFreezEvent,
-  BalanceFreezEventHandler,
-  BalancePatchEvent,
-  BalancePatchEventHandler,
-  BalanceTransactEvent,
-  BalanceTransactEventHandler,
-  BalanceUnfreezEvent,
-  BalanceUnfreezEventHandler,
-  CandleEvent,
-  CandleEventHandler,
-  InstrumentPatchEvent,
-  InstrumentPatchEventHandler,
-  InstrumentSubscriptionEvent,
-  InstrumentSubscriptionEventHandler,
-  OrderbookPatchEvent,
-  OrderbookPatchEventHandler,
-  OrderCanceledEvent,
-  OrderCanceledEventHandler,
-  OrderCancelFailedEvent,
-  OrderCancelFailedEventHandler,
-  OrderCancelingEvent,
-  OrderCancelingEventHandler,
-  OrderFilledEvent,
-  OrderFilledEventHandler,
-  OrderLoadEvent,
-  OrderLoadEventHandler,
-  OrderNewEvent,
-  OrderNewEventHandler,
-  OrderPendingEvent,
-  OrderPendingEventHandler,
-  OrderRejectedEvent,
-  OrderRejectedEventHandler,
-  PositionLoadEvent,
-  PositionLoadEventHandler,
-  PositionPatchEvent,
-  PositionPatchEventHandler,
-  StoreEvent,
-  TradePatchEvent,
-  TradePatchEventHandler
-} from './event';
-import { State, StateChangeTracker } from './store.state';
+import { StoreEvent } from './store.event';
+import { State, StateChangeTracker } from './store-state';
 
-export class Store extends Topic<StoreEvent, any> implements StateChangeTracker {
-  private readonly pendingChanges = new Set<Component>();
+export class Store implements StateChangeTracker {
+  private readonly pendingChanges = new Array<Component>();
   private readonly changes = new Subject<Component>();
-  private readonly state = new BehaviorSubject<State>(new State());
+
+  readonly snapshot = new State();
 
   get changes$(): Observable<Component> {
     return this.changes.asObservable();
   }
 
-  get snapshot(): State {
-    return this.state.value;
-  }
-
   dispatch(...events: StoreEvent[]) {
     for (const event of events) {
-      super.dispatch(event, {});
+      event.handle(this.snapshot, this);
     }
 
     this.commitPendingChanges();
   }
 
   commit(component: Component) {
-    this.pendingChanges.add(component);
+    this.pendingChanges.push(component);
   }
 
   commitPendingChanges() {
     this.pendingChanges.forEach(it => this.changes.next(it));
-    this.pendingChanges.clear();
+    this.pendingChanges.splice(0, this.pendingChanges.length);
   }
 
   dispose() {
-    this.state.complete();
     this.changes.complete();
   }
-
-  /**
-   * @see InstrumentPatchEventHandler
-   */
-  @handler(InstrumentPatchEvent)
-  onInstrumentPatch(event: InstrumentPatchEvent) {
-    return InstrumentPatchEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see InstrumentSubscribedPatchEventHandler
-   */
-  @handler(InstrumentSubscriptionEvent)
-  onInstrumentSubscription(event: InstrumentSubscriptionEvent) {
-    return InstrumentSubscriptionEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see BalancePatchEventHandler
-   */
-  @handler(BalancePatchEvent)
-  onBalancePatch(event: BalancePatchEvent) {
-    return BalancePatchEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see BalanceTransactEventHandler
-   */
-  @handler(BalanceTransactEvent)
-  onBalanceTransact(event: BalanceTransactEvent) {
-    return BalanceTransactEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see BalanceFreezEventHandler
-   */
-  @handler(BalanceFreezEvent)
-  onBalanceFreez(event: BalanceFreezEvent) {
-    return BalanceFreezEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see BalanceUnfreezEventHandler
-   */
-  @handler(BalanceUnfreezEvent)
-  onBalanceUnfreez(event: BalanceUnfreezEvent) {
-    return BalanceUnfreezEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see OrderLoadEventHandler
-   */
-  @handler(OrderLoadEvent)
-  onOrderLoad(event: OrderLoadEvent) {
-    return OrderLoadEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see OrderNewEventHandler
-   */
-  @handler(OrderNewEvent)
-  onOrderNew(event: OrderNewEvent) {
-    return OrderNewEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see OrderPendingEventHandler
-   */
-  @handler(OrderPendingEvent)
-  onOrderPending(event: OrderPendingEvent) {
-    return OrderPendingEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see OrderFilledEventHandler
-   */
-  @handler(OrderFilledEvent)
-  onOrderFilled(event: OrderFilledEvent) {
-    return OrderFilledEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see OrderCancelingEventHandler
-   */
-  @handler(OrderCancelingEvent)
-  onOrderCanceling(event: OrderCancelingEvent) {
-    return OrderCancelingEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see OrderCanceledEventHandler
-   */
-  @handler(OrderCanceledEvent)
-  onOrderCanceled(event: OrderCanceledEvent) {
-    return OrderCanceledEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see OrderCancelFailedEventHandler
-   */
-  @handler(OrderCancelFailedEvent)
-  onOrderCancelFailed(event: OrderCancelFailedEvent) {
-    return OrderCancelFailedEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see OrderRejectedEventHandler
-   */
-  @handler(OrderRejectedEvent)
-  onOrderRejected(event: OrderRejectedEvent) {
-    return OrderRejectedEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see OrderbookPatchEventHandler
-   */
-  @handler(OrderbookPatchEvent)
-  onOrderbookPatch(event: OrderbookPatchEvent) {
-    return OrderbookPatchEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see PositionLoadEventHandler
-   */
-  @handler(PositionLoadEvent)
-  onPositionLoad(event: PositionLoadEvent) {
-    return PositionLoadEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see PositionPatchEventHandler
-   */
-  @handler(PositionPatchEvent)
-  onPositionPatch(event: PositionPatchEvent) {
-    return PositionPatchEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see TradePatchEventHandler
-   */
-  @handler(TradePatchEvent)
-  onTradePatch(event: TradePatchEvent) {
-    return TradePatchEventHandler(event, this.snapshot, this);
-  }
-
-  /**
-   * @see CandleEventHandler
-   */
-  @handler(CandleEvent)
-  onCandle(event: CandleEvent) {
-    return CandleEventHandler(event, this.snapshot, this);
-  }
 }

package/dist/adapter/paper/simulator/paper-margin-simulator.d.ts

@@ -1,10 +0,0 @@
-import { Order } from '../../../domain';
-import { PaperAdapter } from '..';
-import { PaperSimulator } from './paper-simulator';
-export declare class PaperMarginSimulator extends PaperSimulator {
-    leverage: number;
-    constructor(adapter: PaperAdapter);
-    onOrderOpened(order: Order): void;
-    onOrderCompleted(order: Order, averageExecutionRate: number, timestamp: number): void;
-    onOrderCanceled(order: Order): void;
-}