@quantform/core 0.4.11 → 0.5.15

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

@@ -0,0 +1,214 @@
+import { InstrumentSelector, Order } from '../domain';
+import { timestamp } from '../shared';
+import { StoreEvent } from './store.event';
+import { InnerSet, State, StateChangeTracker } from './store-state';
+
+export class OrderLoadEvent implements StoreEvent {
+  constructor(readonly order: Order, readonly timestamp: timestamp) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    this.order.timestamp = this.timestamp;
+
+    const orderByInstrument = state.order.tryGetOrSet(
+      this.order.instrument.id,
+      () => new InnerSet<Order>(this.order.instrument.id)
+    );
+
+    orderByInstrument.upsert(this.order);
+  }
+}
+
+export class OrderNewEvent implements StoreEvent {
+  constructor(readonly order: Order, readonly timestamp: timestamp) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    if (this.order.state != 'NEW') {
+      throw new Error(`Order is not new`);
+    }
+
+    this.order.createdAt = this.timestamp;
+    this.order.timestamp = this.timestamp;
+
+    const orderByInstrument = state.order.tryGetOrSet(
+      this.order.instrument.id,
+      () => new InnerSet<Order>(this.order.instrument.id)
+    );
+
+    orderByInstrument.upsert(this.order);
+
+    changes.commit(this.order);
+  }
+}
+
+export class OrderPendingEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const order = state.order
+      .tryGetOrSet(this.instrument.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      })
+      .tryGetOrSet(this.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      });
+
+    if (order.state != 'NEW') {
+      throw new Error(`Order is not NEW: ${order.state}`);
+    }
+
+    order.state = 'PENDING';
+    order.timestamp = this.timestamp;
+
+    changes.commit(order);
+  }
+}
+
+export class OrderFilledEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: InstrumentSelector,
+    readonly averageExecutionRate: number,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const order = state.order
+      .tryGetOrSet(this.instrument.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      })
+      .tryGetOrSet(this.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      });
+
+    if (order.state != 'PENDING' && order.state != 'CANCELING') {
+      throw new Error(`Order is not PENDING or CANCELING: ${order.state}`);
+    }
+
+    order.state = 'FILLED';
+    order.timestamp = this.timestamp;
+    order.quantityExecuted = order.quantity;
+    order.averageExecutionRate = this.averageExecutionRate;
+
+    changes.commit(order);
+  }
+}
+
+export class OrderCancelingEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const order = state.order
+      .tryGetOrSet(this.instrument.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      })
+      .tryGetOrSet(this.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      });
+
+    if (order.state == 'CANCELING' || order.state == 'CANCELED') {
+      return;
+    }
+
+    if (order.state != 'PENDING') {
+      throw new Error(`Order is not PENDING: ${order.state}`);
+    }
+
+    order.state = 'CANCELING';
+    order.timestamp = this.timestamp;
+
+    changes.commit(order);
+  }
+}
+
+export class OrderCanceledEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const order = state.order
+      .tryGetOrSet(this.instrument.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      })
+      .tryGetOrSet(this.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      });
+
+    if (order.state == 'CANCELED') {
+      return;
+    }
+
+    if (order.state != 'CANCELING') {
+      throw new Error(`Order is not CANCELING: ${order.state}`);
+    }
+
+    order.state = 'CANCELED';
+    order.timestamp = this.timestamp;
+
+    changes.commit(order);
+  }
+}
+
+export class OrderCancelFailedEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const order = state.order
+      .tryGetOrSet(this.instrument.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      })
+      .tryGetOrSet(this.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      });
+
+    if (order.state != 'CANCELING') {
+      return;
+    }
+
+    order.state = 'PENDING';
+    order.timestamp = this.timestamp;
+
+    changes.commit(order);
+  }
+}
+
+export class OrderRejectedEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const order = state.order
+      .tryGetOrSet(this.instrument.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      })
+      .tryGetOrSet(this.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      });
+
+    if (order.state != 'NEW') {
+      throw new Error(`Order is not NEW: ${order.state}`);
+    }
+
+    order.state = 'REJECTED';
+    order.timestamp = this.timestamp;
+
+    changes.commit(order);
+  }
+}

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

@@ -0,0 +1,54 @@
+import { InstrumentSelector, Orderbook } from '../domain';
+import { timestamp } from '../shared';
+import { StoreEvent } from './store.event';
+import { State, StateChangeTracker } from './store-state';
+
+export class OrderbookPatchEvent implements StoreEvent {
+  constructor(
+    readonly instrument: InstrumentSelector,
+    readonly bestAskRate: number,
+    readonly bestAskQuantity: number,
+    readonly bestBidRate: number,
+    readonly bestBidQuantity: 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 orderbook = state.orderbook.tryGetOrSet(
+      this.instrument.id,
+      () => new Orderbook(state.universe.instrument.get(this.instrument.id))
+    );
+
+    state.timestamp = this.timestamp;
+
+    orderbook.timestamp = this.timestamp;
+    orderbook.bestAskRate = orderbook.instrument.quote.fixed(this.bestAskRate);
+    orderbook.bestAskQuantity = orderbook.instrument.base.fixed(this.bestAskQuantity);
+    orderbook.bestBidRate = orderbook.instrument.quote.fixed(this.bestBidRate);
+    orderbook.bestBidQuantity = orderbook.instrument.base.fixed(this.bestBidQuantity);
+
+    const quote = state.balance.get(orderbook.instrument.quote.id);
+
+    if (quote) {
+      for (const position of Object.values(quote.position)) {
+        if (position.instrument.id != orderbook.instrument.id) {
+          continue;
+        }
+
+        const rate = position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
+
+        position.calculateEstimatedUnrealizedPnL(rate);
+      }
+
+      if (quote.total < 0) {
+        throw new Error('liquidated');
+      }
+    }
+
+    changes.commit(orderbook);
+  }
+}

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,7 +1,7 @@
-import { TradePatchEvent } from '.';
 import { Store } from '..';
-import { Asset, Instrument } from '../../domain';
-import { now } from '../../shared';
+import { Asset, Instrument } from '../domain';
+import { now } from '../shared';
+import { TradePatchEvent } from '.';
 
 const instrument = new Instrument(
   new Asset('btc', 'binance', 8),
@@ -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;
+}