@quantform/core 0.3.252 → 0.3.256

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.pending).length).toEqual(1);
+    expect(store.snapshot.order.pending[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,7 +11,11 @@ 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) {
@@ -31,7 +35,7 @@ export function OrderLoadEventHandler(event: OrderLoadEvent, state: State) {
       break;
   }
 
-  return event.order;
+  changes.commit(event.order);
 }
 
 @event
@@ -41,7 +45,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`);
   }
@@ -51,7 +59,7 @@ export function OrderNewEventHandler(event: OrderNewEvent, state: State) {
 
   state.order.pending[event.order.id] = event.order;
 
-  return event.order;
+  changes.commit(event.order);
 }
 
 @event
@@ -61,7 +69,11 @@ 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}`);
   }
@@ -75,7 +87,7 @@ export function OrderPendingEventHandler(event: OrderPendingEvent, state: State)
   order.state = 'PENDING';
   order.timestamp = event.timestamp;
 
-  return order;
+  changes.commit(order);
 }
 
 @event
@@ -89,7 +101,11 @@ export class OrderFilledEvent implements StoreEvent {
   ) {}
 }
 
-export function OrderFilledEventHandler(event: OrderFilledEvent, state: State) {
+export function OrderFilledEventHandler(
+  event: OrderFilledEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   if (!(event.id in state.order.pending)) {
     throw new Error(`Trying to patch unknown order: ${event.id}`);
   }
@@ -109,7 +125,7 @@ export function OrderFilledEventHandler(event: OrderFilledEvent, state: State) {
 
   state.order.filled[event.id] = order;
 
-  return order;
+  changes.commit(order);
 }
 
 @event
@@ -119,7 +135,11 @@ export class OrderCancelingEvent implements StoreEvent {
   constructor(readonly id: string, readonly timestamp: timestamp) {}
 }
 
-export function OrderCancelingEventHandler(event: OrderCancelingEvent, state: State) {
+export function OrderCancelingEventHandler(
+  event: OrderCancelingEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   if (!(event.id in state.order.pending)) {
     throw new Error(`Trying to patch unknown order: ${event.id}`);
   }
@@ -137,7 +157,7 @@ export function OrderCancelingEventHandler(event: OrderCancelingEvent, state: St
   order.state = 'CANCELING';
   order.timestamp = event.timestamp;
 
-  return order;
+  changes.commit(order);
 }
 
 @event
@@ -147,7 +167,11 @@ export class OrderCanceledEvent implements StoreEvent {
   constructor(readonly id: string, readonly timestamp: timestamp) {}
 }
 
-export function OrderCanceledEventHandler(event: OrderCanceledEvent, state: State) {
+export function OrderCanceledEventHandler(
+  event: OrderCanceledEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   const order = state.order.pending[event.id];
 
   if (order.state == 'CANCELED') {
@@ -165,7 +189,7 @@ export function OrderCanceledEventHandler(event: OrderCanceledEvent, state: Stat
 
   state.order.canceled[event.id] = order;
 
-  return order;
+  changes.commit(order);
 }
 
 @event
@@ -177,7 +201,8 @@ export class OrderCancelFailedEvent implements StoreEvent {
 
 export function OrderCancelFailedEventHandler(
   event: OrderCancelFailedEvent,
-  state: State
+  state: State,
+  changes: StateChangeTracker
 ) {
   const order = state.order.pending[event.id];
 
@@ -188,7 +213,7 @@ export function OrderCancelFailedEventHandler(
   order.state = 'PENDING';
   order.timestamp = event.timestamp;
 
-  return order;
+  changes.commit(order);
 }
 
 @event
@@ -198,7 +223,11 @@ export class OrderRejectedEvent implements StoreEvent {
   constructor(readonly id: string, readonly timestamp: timestamp) {}
 }
 
-export function OrderRejectedEventHandler(event: OrderRejectedEvent, state: State) {
+export function OrderRejectedEventHandler(
+  event: OrderRejectedEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   const order = state.order.pending[event.id];
 
   if (order.state != 'NEW') {
@@ -212,5 +241,5 @@ export function OrderRejectedEventHandler(event: OrderRejectedEvent, state: Stat
 
   state.order.rejected[event.id] = order;
 
-  return order;
+  changes.commit(order);
 }

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

@@ -2,7 +2,7 @@ import { event } from '../../shared/topic';
 import { timestamp } from '../../shared';
 import { InstrumentSelector } from '../../domain/instrument';
 import { Orderbook } from '../../domain/orderbook';
-import { State } from '../store.state';
+import { State, StateChangeTracker } from '../store.state';
 import { StoreEvent } from './store.event';
 
 @event
@@ -19,7 +19,11 @@ export class OrderbookPatchEvent implements StoreEvent {
   ) {}
 }
 
-export function OrderbookPatchEventHandler(event: OrderbookPatchEvent, state: State) {
+export function OrderbookPatchEventHandler(
+  event: OrderbookPatchEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   const instrumentKey = event.instrument.toString();
 
   if (!(instrumentKey in state.subscription.instrument)) {
@@ -62,5 +66,5 @@ export function OrderbookPatchEventHandler(event: OrderbookPatchEvent, state: St
     }
   }
 
-  return orderbook;
+  changes.commit(orderbook);
 }

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

@@ -1,7 +1,7 @@
 import { event } from '../../shared/topic';
 import { timestamp } from '../../shared';
 import { Position, Instrument, PositionMode } from '../../domain';
-import { State } from '../store.state';
+import { State, StateChangeTracker } from '../store.state';
 import { StoreEvent } from './store.event';
 
 @event
@@ -11,7 +11,11 @@ export class PositionLoadEvent implements StoreEvent {
   constructor(readonly position: Position, readonly timestamp: timestamp) {}
 }
 
-export function PositionLoadEventHandler(event: PositionLoadEvent, state: State) {
+export function PositionLoadEventHandler(
+  event: PositionLoadEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   if (
     event.position.instrument.toString()! in state.subscription.instrument ||
     event.position.size == 0
@@ -50,7 +54,11 @@ export class PositionPatchEvent implements StoreEvent {
   ) {}
 }
 
-export function PositionPatchEventHandler(event: PositionPatchEvent, state: State) {
+export function PositionPatchEventHandler(
+  event: PositionPatchEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   if (!(event.instrument.toString() in state.subscription.instrument)) {
     return;
   }
@@ -74,10 +82,9 @@ export function PositionPatchEventHandler(event: PositionPatchEvent, state: Stat
         position.calculatePnL(rate);
       }
 
-      return [position, balance];
+      changes.commit(position);
+      changes.commit(balance);
     }
-
-    return;
   }
 
   if (!position) {
@@ -97,5 +104,6 @@ export function PositionPatchEventHandler(event: PositionPatchEvent, state: Stat
     position.calculatePnL(rate);
   }
 
-  return [position, balance];
+  changes.commit(position);
+  changes.commit(balance);
 }

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

@@ -1,7 +1,7 @@
 import { Asset, Instrument } from '../../domain';
-import { TradePatchEvent, TradePatchEventHandler } from '.';
-import { State } from '../store.state';
+import { TradePatchEvent } from '.';
 import { now } from '../../shared';
+import { Store } from '..';
 
 const instrument = new Instrument(
   new Asset('btc', 'binance', 8),
@@ -12,49 +12,47 @@ const instrument = new Instrument(
 describe('trade patch event tests', () => {
   test('should create a new trade object and patch a store', () => {
     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 TradePatchEvent(instrument, 1000, 0.1, timestamp);
+    store.dispatch(new TradePatchEvent(instrument, 1000, 0.1, timestamp));
 
-    TradePatchEventHandler(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(trade.instrument.toString());
     expect(trade.rate).toEqual(1000);
     expect(trade.quantity).toEqual(0.1);
-    expect(state.timestamp).toEqual(timestamp);
+    expect(store.snapshot.timestamp).toEqual(timestamp);
   });
 
   test('should use the existing instance of trade when patching a store', () => {
-    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;
 
-    TradePatchEventHandler(new TradePatchEvent(instrument, 1000, 0.1, now()), state);
+    store.dispatch(new TradePatchEvent(instrument, 1000, 0.1, now()));
 
     const timestamp = now();
-    const trade = state.trade[instrument.toString()];
+    const trade = store.snapshot.trade[instrument.toString()];
 
-    TradePatchEventHandler(new TradePatchEvent(instrument, 2000, 0.2, timestamp), state);
+    store.dispatch(new TradePatchEvent(instrument, 2000, 0.2, now()));
 
     expect(trade.timestamp).toEqual(timestamp);
     expect(trade.instrument.toString()).toEqual(instrument.toString());
     expect(trade.rate).toEqual(2000);
     expect(trade.quantity).toEqual(0.2);
-    expect(state.timestamp).toEqual(timestamp);
+    expect(store.snapshot.timestamp).toEqual(timestamp);
   });
 
   test('should throw exception when patching unsubscribed instrument', () => {
-    const fn = () => {
-      const event = new TradePatchEvent(instrument, 1000, 0.1, now());
+    const store = new Store();
 
-      TradePatchEventHandler(event, new State());
+    const fn = () => {
+      store.dispatch(new TradePatchEvent(instrument, 1000, 0.1, now()));
     };
 
     expect(fn).toThrow(Error);

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

@@ -2,7 +2,7 @@ import { event } from '../../shared/topic';
 import { timestamp } from '../../shared';
 import { Trade } from '../../domain';
 import { InstrumentSelector } from '../../domain/instrument';
-import { State } from '../store.state';
+import { State, StateChangeTracker } from '../store.state';
 import { StoreEvent } from './store.event';
 
 /**
@@ -24,7 +24,11 @@ export class TradePatchEvent implements StoreEvent {
  * Patches a store with specific event @see TradePatchEvent
  * If there is no specific @see Trade in store, it will create a new one.
  */
-export function TradePatchEventHandler(event: TradePatchEvent, state: State) {
+export function TradePatchEventHandler(
+  event: TradePatchEvent,
+  state: State,
+  changes: StateChangeTracker
+) {
   const instrumentKey = event.instrument.toString();
 
   if (!(instrumentKey in state.subscription.instrument)) {
@@ -44,5 +48,5 @@ export function TradePatchEventHandler(event: TradePatchEvent, state: State) {
   trade.rate = trade.instrument.quote.fixed(event.rate);
   trade.quantity = trade.instrument.base.fixed(event.quantity);
 
-  return trade;
+  changes.commit(trade);
 }

package/src/store/store.state.ts

@@ -7,13 +7,19 @@ import {
   Asset,
   Trade,
   AssetSelector,
-  InstrumentSelector
+  InstrumentSelector,
+  Component
 } from '../domain';
 
+export interface StateChangeTracker {
+  commit(component: Component);
+  commitPendingChanges();
+}
+
 export class State {
   timestamp: timestamp;
 
-  // all available trasing assets and instruments
+  // available trading assets and instruments
   universe: {
     asset: Record<string, Asset>;
     instrument: Record<string, Instrument>;