@quantform/core 0.3.254 → 0.3.259

package/src/session/session.ts

@@ -191,14 +191,12 @@ export class Session {
   /**
    * Subscribes to trade/ticker changes.
    */
-  trade(selector?: InstrumentSelector): Observable<Trade> {
+  trade(selector: InstrumentSelector): Observable<Trade> {
     this.subscribe([selector]);
 
     return this.store.changes$.pipe(
       filter(
-        it =>
-          it instanceof Trade &&
-          (!selector || it.instrument.toString() == selector.toString())
+        it => it instanceof Trade && it.instrument.toString() == selector.toString()
       ),
       map(it => it as Trade)
     );
@@ -208,14 +206,12 @@ export class Session {
    * Subscribes to orderbook changes.
    * Right now you can access only best bid and best ask.
    */
-  orderbook(selector?: InstrumentSelector): Observable<Orderbook> {
+  orderbook(selector: InstrumentSelector): Observable<Orderbook> {
     this.subscribe([selector]);
 
     return this.store.changes$.pipe(
       filter(
-        it =>
-          it instanceof Orderbook &&
-          (!selector || it.instrument.toString() == selector.toString())
+        it => it instanceof Orderbook && it.instrument.toString() == selector.toString()
       ),
       map(it => it as Orderbook)
     );
@@ -224,14 +220,12 @@ export class Session {
   /**
    * Subscribes to position on leveraged market.
    */
-  position(selector?: InstrumentSelector): Observable<Position> {
+  position(selector: InstrumentSelector): Observable<Position> {
     this.subscribe([selector]);
 
     return this.store.changes$.pipe(
       filter(
-        it =>
-          it instanceof Position &&
-          (!selector || it.instrument.toString() == selector.toString())
+        it => it instanceof Position && it.instrument.toString() == selector.toString()
       ),
       map(it => it as Position)
     );
@@ -256,73 +250,44 @@ export class Session {
     );
   }
 
-  order(selector?: InstrumentSelector): Observable<Order> {
+  order(selector: InstrumentSelector): Observable<Order> {
     this.subscribe([selector]);
 
     return this.store.changes$.pipe(
       filter(
-        it =>
-          it instanceof Order &&
-          (!selector || it.instrument.toString() == selector.toString())
+        it => it instanceof Order && it.instrument.toString() == selector.toString()
       ),
       map(it => it as Order)
     );
   }
 
-  private ordersOf(
-    orders: Order[],
-    states: OrderState[],
-    selector?: InstrumentSelector
-  ): Observable<Order[]> {
+  orders(selector: InstrumentSelector, states?: OrderState[]): Observable<Order[]> {
     this.subscribe([selector]);
 
     return this.store.changes$.pipe(
       filter(
         it =>
           it instanceof Order &&
-          (!selector || it.instrument.toString() == selector.toString()) &&
-          (states.indexOf(it.state) >= 0 || states.length == 0)
+          it.instrument.toString() == selector.toString() &&
+          (!states || states.includes(it.state))
       ),
-      map(() =>
-        Object.values(orders)
-          .filter(it => !selector || it.instrument.toString() == selector.toString())
-          .sort((lhs, rhs) => rhs.createdAt - lhs.createdAt)
-      ),
-      startWith(
-        Object.values(orders)
-          .filter(it => !selector || it.instrument.toString() == selector.toString())
+      map(() => this.store.snapshot.order),
+      startWith(this.store.snapshot.order),
+      map(it =>
+        Object.values(it)
+          .filter(
+            it =>
+              it.instrument.toString() == selector.toString() &&
+              (states ? states.includes(it.state) : true)
+          )
           .sort((lhs, rhs) => rhs.createdAt - lhs.createdAt)
       )
     );
   }
 
-  pending(selector?: InstrumentSelector): Observable<Order[]> {
-    return this.ordersOf(
-      Object.values(this.store.snapshot.order.pending),
-      ['PENDING', 'NEW'],
-      selector
-    );
-  }
-
-  filled(selector?: InstrumentSelector): Observable<Order[]> {
-    return this.ordersOf(
-      Object.values(this.store.snapshot.order.filled),
-      ['FILLED'],
-      selector
-    );
-  }
-
-  canceled(selector?: InstrumentSelector): Observable<Order[]> {
-    return this.ordersOf(
-      Object.values(this.store.snapshot.order.canceled),
-      ['CANCELING', 'CANCELED'],
-      selector
-    );
-  }
-
   balance(selector: AssetSelector): Observable<Balance> {
     return this.store.changes$.pipe(
-      startWith(selector ? this.store.snapshot.balance[selector.toString()] : null),
+      startWith(this.store.snapshot.balance[selector.toString()]),
       filter(
         it =>
           it instanceof Balance &&

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

@@ -2,7 +2,7 @@ import { event } from '../../shared/topic';
 import { timestamp } from '../../shared';
 import { AssetSelector } from '../../domain/asset';
 import { Balance } from '../../domain/balance';
-import { State } from '../store.state';
+import { State, StateChangeTracker } from '../store.state';
 import { StoreEvent } from './store.event';
 
 /**
@@ -23,7 +23,11 @@ export class BalancePatchEvent implements StoreEvent {
 /**
  * @see BalancePatchEvent
  */
-export function BalancePatchEventHandler(event: BalancePatchEvent, state: State) {
+export function BalancePatchEventHandler(
+  event: BalancePatchEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   let balance = state.balance[event.asset.toString()];
 
   if (!balance) {
@@ -41,7 +45,7 @@ export function BalancePatchEventHandler(event: BalancePatchEvent, state: State)
 
   state.timestamp = event.timestamp;
 
-  return balance;
+  changes.commit(balance);
 }
 
 /**
@@ -61,7 +65,11 @@ export class BalanceTransactEvent implements StoreEvent {
 /**
  * @see BalanceTransactEvent
  */
-export function BalanceTransactEventHandler(event: BalanceTransactEvent, state: State) {
+export function BalanceTransactEventHandler(
+  event: BalanceTransactEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   let balance = state.balance[event.asset.toString()];
 
   if (!balance) {
@@ -77,7 +85,7 @@ export function BalanceTransactEventHandler(event: BalanceTransactEvent, state:
 
   state.timestamp = event.timestamp;
 
-  return balance;
+  changes.commit(balance);
 }
 
 /**
@@ -97,7 +105,11 @@ export class BalanceFreezEvent implements StoreEvent {
 /**
  * @see BalanceFreezEvent
  */
-export function BalanceFreezEventHandler(event: BalanceFreezEvent, state: State) {
+export function BalanceFreezEventHandler(
+  event: BalanceFreezEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   const balance = state.balance[event.asset.toString()];
 
   if (!balance) {
@@ -109,7 +121,7 @@ export function BalanceFreezEventHandler(event: BalanceFreezEvent, state: State)
 
   state.timestamp = event.timestamp;
 
-  return balance;
+  changes.commit(balance);
 }
 
 /**
@@ -129,7 +141,11 @@ export class BalanceUnfreezEvent implements StoreEvent {
 /**
  * @see BalanceUnfreezEvent
  */
-export function BalanceUnfreezEventHandler(event: BalanceUnfreezEvent, state: State) {
+export function BalanceUnfreezEventHandler(
+  event: BalanceUnfreezEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   const balance = state.balance[event.asset.toString()];
 
   if (!balance) {
@@ -141,5 +157,5 @@ export function BalanceUnfreezEventHandler(event: BalanceUnfreezEvent, state: St
 
   state.timestamp = event.timestamp;
 
-  return balance;
+  changes.commit(balance);
 }

package/src/store/event/store-candle.event.spec.ts

@@ -1,7 +1,7 @@
 import { Asset, Instrument } from '../../domain';
-import { CandleEvent, CandleEventHandler } from '.';
-import { State } from '../store.state';
+import { CandleEvent } from '.';
 import { now } from '../../shared';
+import { Store } from '../store';
 
 const instrument = new Instrument(
   new Asset('btc', 'binance', 8),
@@ -12,21 +12,19 @@ const instrument = new Instrument(
 describe('candle patch event tests', () => {
   test('should patch trade object', () => {
     const timestamp = now();
-    const state = new State();
+    const store = new Store();
 
-    state.universe.instrument[instrument.toString()] = instrument;
-    state.subscription.instrument[instrument.toString()] = instrument;
+    store.snapshot.universe.instrument[instrument.toString()] = instrument;
+    store.snapshot.subscription.instrument[instrument.toString()] = instrument;
 
-    const event = new CandleEvent(instrument, 1, 1, 1, 1, 1, 1, timestamp);
+    store.dispatch(new CandleEvent(instrument, 1, 1, 1, 1, 1, 1, timestamp));
 
-    CandleEventHandler(event, state);
-
-    const trade = state.trade[instrument.toString()];
+    const trade = store.snapshot.trade[instrument.toString()];
 
     expect(trade.timestamp).toEqual(timestamp);
     expect(trade.instrument.toString()).toEqual(instrument.toString());
     expect(trade.rate).toEqual(1);
     expect(trade.quantity).toEqual(1);
-    expect(state.timestamp).toEqual(timestamp);
+    expect(store.snapshot.timestamp).toEqual(timestamp);
   });
 });

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

@@ -5,6 +5,7 @@ import { InstrumentSelector } from '../../domain';
 import { State } from '../store.state';
 import { StoreEvent } from './store.event';
 import { event } from '../../shared/topic';
+import { StateChangeTracker } from '..';
 
 @event
 export class CandleEvent implements StoreEvent {
@@ -22,36 +23,49 @@ export class CandleEvent implements StoreEvent {
   ) {}
 }
 
-export function CandleEventHandler(event: CandleEvent, state: State) {
+export function CandleEventHandler(
+  event: CandleEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   const instrument = state.universe.instrument[event.instrument.toString()];
 
-  // patch trade object
-  const trade = TradePatchEventHandler(
-    {
-      type: 'trade-patch',
-      instrument: event.instrument,
-      quantity: event.volume,
-      rate: event.close,
-      timestamp: event.timestamp
-    },
-    state
-  );
-
-  // patch orderbook by assuming candle close price is mid orderbook price
-  const orderbook = OrderbookPatchEventHandler(
-    {
-      type: 'orderbook-patch',
-      instrument: event.instrument,
-      bestAskQuantity: event.volume * 0.5,
-      bestAskRate: event.close + instrument.quote.tickSize,
-      bestBidQuantity: event.volume * 0.5,
-      bestBidRate: event.close - instrument.quote.tickSize,
-      timestamp: event.timestamp
-    },
-    state
-  );
-
-  state.timestamp = event.timestamp;
-
-  return [trade, orderbook];
+  const patch = (timestamp: number, rate: number) => {
+    // patch trade object
+    TradePatchEventHandler(
+      {
+        type: 'trade-patch',
+        instrument: event.instrument,
+        quantity: event.volume,
+        rate,
+        timestamp
+      },
+      state,
+      changes
+    );
+
+    // patch orderbook by assuming candle close price is mid orderbook price
+    OrderbookPatchEventHandler(
+      {
+        type: 'orderbook-patch',
+        instrument: event.instrument,
+        bestAskQuantity: instrument.base.fixed(event.volume * 0.5),
+        bestAskRate: rate,
+        bestBidQuantity: instrument.base.fixed(event.volume * 0.5),
+        bestBidRate: rate,
+        timestamp
+      },
+      state,
+      changes
+    );
+
+    state.timestamp = event.timestamp;
+
+    changes.commitPendingChanges();
+  };
+
+  patch(event.timestamp, instrument.quote.fixed(event.open));
+  patch(event.timestamp, instrument.quote.fixed(event.high));
+  patch(event.timestamp, instrument.quote.fixed(event.low));
+  patch(event.timestamp, instrument.quote.fixed(event.close));
 }

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

@@ -2,7 +2,7 @@ import { event } from '../../shared/topic';
 import { timestamp } from '../../shared';
 import { Asset, Commission } from '../../domain';
 import { Instrument, InstrumentSelector } from '../../domain/instrument';
-import { State } from '../../store';
+import { State, StateChangeTracker } from '../../store';
 import { StoreEvent } from './store.event';
 
 @event
@@ -13,13 +13,17 @@ export class InstrumentPatchEvent implements StoreEvent {
     readonly timestamp: timestamp,
     readonly base: Asset,
     readonly quote: Asset,
-    readonly commision: Commission,
+    readonly commission: Commission,
     readonly raw: string,
     readonly leverage?: number
   ) {}
 }
 
-export function InstrumentPatchEventHandler(event: InstrumentPatchEvent, state: State) {
+export function InstrumentPatchEventHandler(
+  event: InstrumentPatchEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   const selector = new InstrumentSelector(
     event.base.name,
     event.quote.name,
@@ -37,13 +41,13 @@ export function InstrumentPatchEventHandler(event: InstrumentPatchEvent, state:
   }
 
   instrument.timestamp = event.timestamp;
-  instrument.commission = event.commision;
+  instrument.commission = event.commission;
 
   if (event.leverage) {
     instrument.leverage = event.leverage;
   }
 
-  return instrument;
+  changes.commit(instrument);
 }
 
 @event
@@ -59,7 +63,8 @@ export class InstrumentSubscriptionEvent implements StoreEvent {
 
 export function InstrumentSubscriptionEventHandler(
   event: InstrumentSubscriptionEvent,
-  state: State
+  state: State,
+  changes: StateChangeTracker
 ) {
   const instrumentKey = event.instrument.toString();
 
@@ -75,5 +80,5 @@ export function InstrumentSubscriptionEventHandler(
     state.subscription.asset[instrument.quote.toString()] = instrument.quote;
   }
 
-  return instrument;
+  changes.commit(instrument);
 }

package/src/store/event/store-order.event.spec.ts

@@ -1,7 +1,7 @@
-import { State } from '../';
 import { now } from '../../shared';
 import { Asset, Instrument, Order } from '../../domain';
-import { OrderLoadEvent, OrderLoadEventHandler } from './store-order.event';
+import { OrderLoadEvent } from './store-order.event';
+import { Store } from '../store';
 
 const instrument = new Instrument(
   new Asset('btc', 'binance', 8),
@@ -12,17 +12,17 @@ const instrument = new Instrument(
 describe('order load event tests', () => {
   test('should load order to store', () => {
     const timestamp = now();
-    const state = new State();
+    const store = new Store();
     const order = Order.buyMarket(instrument, 1.0);
 
     order.state = 'PENDING';
 
-    state.universe.instrument[instrument.toString()] = instrument;
-    state.subscription.instrument[instrument.toString()] = instrument;
+    store.snapshot.universe.instrument[instrument.toString()] = instrument;
+    store.snapshot.subscription.instrument[instrument.toString()] = instrument;
 
-    OrderLoadEventHandler(new OrderLoadEvent(order, timestamp), state);
+    store.dispatch(new OrderLoadEvent(order, timestamp));
 
-    expect(Object.keys(state.order.pending).length).toEqual(1);
-    expect(state.order.pending[order.id]).toEqual(order);
+    expect(Object.keys(store.snapshot.order).length).toEqual(1);
+    expect(store.snapshot.order[order.id]).toEqual(order);
   });
 });

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

@@ -1,7 +1,7 @@
 import { event } from '../../shared/topic';
 import { timestamp } from '../../shared';
 import { Order } from '../../domain';
-import { State } from '../store.state';
+import { State, StateChangeTracker } from '../store.state';
 import { StoreEvent } from './store.event';
 
 @event
@@ -11,27 +11,16 @@ export class OrderLoadEvent implements StoreEvent {
   constructor(readonly order: Order, readonly timestamp: timestamp) {}
 }
 
-export function OrderLoadEventHandler(event: OrderLoadEvent, state: State) {
+export function OrderLoadEventHandler(
+  event: OrderLoadEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   event.order.timestamp = event.timestamp;
 
-  switch (event.order.state) {
-    case 'NEW':
-    case 'PENDING':
-      state.order.pending[event.order.id] = event.order;
-      break;
-    case 'FILLED':
-      state.order.filled[event.order.id] = event.order;
-      break;
-    case 'CANCELING':
-    case 'CANCELED':
-      state.order.canceled[event.order.id] = event.order;
-      break;
-    case 'REJECTED':
-      state.order.rejected[event.order.id] = event.order;
-      break;
-  }
+  state.order[event.order.id] = event.order;
 
-  return event.order;
+  changes.commit(event.order);
 }
 
 @event
@@ -41,7 +30,11 @@ export class OrderNewEvent implements StoreEvent {
   constructor(readonly order: Order, readonly timestamp: timestamp) {}
 }
 
-export function OrderNewEventHandler(event: OrderNewEvent, state: State) {
+export function OrderNewEventHandler(
+  event: OrderNewEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   if (event.order.state != 'NEW') {
     throw new Error(`Order is not new`);
   }
@@ -49,9 +42,9 @@ export function OrderNewEventHandler(event: OrderNewEvent, state: State) {
   event.order.createdAt = event.timestamp;
   event.order.timestamp = event.timestamp;
 
-  state.order.pending[event.order.id] = event.order;
+  state.order[event.order.id] = event.order;
 
-  return event.order;
+  changes.commit(event.order);
 }
 
 @event
@@ -61,12 +54,16 @@ export class OrderPendingEvent implements StoreEvent {
   constructor(readonly id: string, readonly timestamp: timestamp) {}
 }
 
-export function OrderPendingEventHandler(event: OrderPendingEvent, state: State) {
+export function OrderPendingEventHandler(
+  event: OrderPendingEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   if (!(event.id in state.order.pending)) {
     throw new Error(`Trying to patch unknown order: ${event.id}`);
   }
 
-  const order = state.order.pending[event.id];
+  const order = state.order[event.id];
 
   if (order.state != 'NEW') {
     throw new Error(`Order is not new`);
@@ -75,7 +72,7 @@ export function OrderPendingEventHandler(event: OrderPendingEvent, state: State)
   order.state = 'PENDING';
   order.timestamp = event.timestamp;
 
-  return order;
+  changes.commit(order);
 }
 
 @event
@@ -89,12 +86,16 @@ export class OrderFilledEvent implements StoreEvent {
   ) {}
 }
 
-export function OrderFilledEventHandler(event: OrderFilledEvent, state: State) {
-  if (!(event.id in state.order.pending)) {
+export function OrderFilledEventHandler(
+  event: OrderFilledEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
+  if (!(event.id in state.order)) {
     throw new Error(`Trying to patch unknown order: ${event.id}`);
   }
 
-  const order = state.order.pending[event.id];
+  const order = state.order[event.id];
 
   if (order.state != 'PENDING' && order.state != 'CANCELING') {
     throw new Error('Order is not pending');
@@ -105,11 +106,7 @@ export function OrderFilledEventHandler(event: OrderFilledEvent, state: State) {
   order.quantityExecuted = order.quantity;
   order.averageExecutionRate = event.averageExecutionRate;
 
-  delete state.order.pending[event.id];
-
-  state.order.filled[event.id] = order;
-
-  return order;
+  changes.commit(order);
 }
 
 @event
@@ -119,12 +116,16 @@ export class OrderCancelingEvent implements StoreEvent {
   constructor(readonly id: string, readonly timestamp: timestamp) {}
 }
 
-export function OrderCancelingEventHandler(event: OrderCancelingEvent, state: State) {
-  if (!(event.id in state.order.pending)) {
+export function OrderCancelingEventHandler(
+  event: OrderCancelingEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
+  if (!(event.id in state.order)) {
     throw new Error(`Trying to patch unknown order: ${event.id}`);
   }
 
-  const order = state.order.pending[event.id];
+  const order = state.order[event.id];
 
   if (order.state == 'CANCELING' || order.state == 'CANCELED') {
     return;
@@ -137,7 +138,7 @@ export function OrderCancelingEventHandler(event: OrderCancelingEvent, state: St
   order.state = 'CANCELING';
   order.timestamp = event.timestamp;
 
-  return order;
+  changes.commit(order);
 }
 
 @event
@@ -147,8 +148,12 @@ export class OrderCanceledEvent implements StoreEvent {
   constructor(readonly id: string, readonly timestamp: timestamp) {}
 }
 
-export function OrderCanceledEventHandler(event: OrderCanceledEvent, state: State) {
-  const order = state.order.pending[event.id];
+export function OrderCanceledEventHandler(
+  event: OrderCanceledEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
+  const order = state.order[event.id];
 
   if (order.state == 'CANCELED') {
     return;
@@ -161,11 +166,7 @@ export function OrderCanceledEventHandler(event: OrderCanceledEvent, state: Stat
   order.state = 'CANCELED';
   order.timestamp = event.timestamp;
 
-  delete state.order.pending[event.id];
-
-  state.order.canceled[event.id] = order;
-
-  return order;
+  changes.commit(order);
 }
 
 @event
@@ -177,9 +178,10 @@ export class OrderCancelFailedEvent implements StoreEvent {
 
 export function OrderCancelFailedEventHandler(
   event: OrderCancelFailedEvent,
-  state: State
+  state: State,
+  changes: StateChangeTracker
 ) {
-  const order = state.order.pending[event.id];
+  const order = state.order[event.id];
 
   if (order.state != 'CANCELING') {
     return;
@@ -188,7 +190,7 @@ export function OrderCancelFailedEventHandler(
   order.state = 'PENDING';
   order.timestamp = event.timestamp;
 
-  return order;
+  changes.commit(order);
 }
 
 @event
@@ -198,8 +200,12 @@ export class OrderRejectedEvent implements StoreEvent {
   constructor(readonly id: string, readonly timestamp: timestamp) {}
 }
 
-export function OrderRejectedEventHandler(event: OrderRejectedEvent, state: State) {
-  const order = state.order.pending[event.id];
+export function OrderRejectedEventHandler(
+  event: OrderRejectedEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
+  const order = state.order[event.id];
 
   if (order.state != 'NEW') {
     throw new Error('Order is not new.');
@@ -208,9 +214,5 @@ export function OrderRejectedEventHandler(event: OrderRejectedEvent, state: Stat
   order.state = 'REJECTED';
   order.timestamp = event.timestamp;
 
-  delete state.order.pending[event.id];
-
-  state.order.rejected[event.id] = order;
-
-  return order;
+  changes.commit(order);
 }