@quantform/core 0.5.13 → 0.5.23

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

@@ -0,0 +1,214 @@
+import { InstrumentSelector, Order } from '../domain';
+import { decimal, 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: decimal,
+    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.spec.ts

@@ -0,0 +1,37 @@
+import { Store } from '..';
+import { Asset, Instrument, Liquidity } from '../domain';
+import { d, now } from '../shared';
+import { OrderbookPatchEvent } from '.';
+
+const instrument = new Instrument(
+  new Asset('btc', 'binance', 8),
+  new Asset('usdt', 'binance', 2),
+  'binance:btc-usdt'
+);
+
+describe('OrderbookPatchEvent', () => {
+  let store: Store;
+
+  beforeEach(() => {
+    store = new Store();
+    store.snapshot.universe.instrument.upsert(instrument);
+    store.snapshot.subscription.instrument.upsert(instrument);
+  });
+
+  test('should set a best bid and ask', () => {
+    const timestamp = now();
+
+    const ask: Liquidity = { rate: d(2), quantity: d(2), next: undefined };
+    const bid: Liquidity = { rate: d(1), quantity: d(1), next: undefined };
+
+    store.dispatch(new OrderbookPatchEvent(instrument, ask, bid, timestamp));
+
+    const orderbook = store.snapshot.orderbook.get(instrument.id);
+
+    expect(orderbook.timestamp).toEqual(timestamp);
+    expect(orderbook.instrument.id).toEqual(orderbook.instrument.id);
+    expect(orderbook.asks).toEqual(ask);
+    expect(orderbook.bids).toEqual(bid);
+    expect(store.snapshot.timestamp).toEqual(timestamp);
+  });
+});

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

@@ -0,0 +1,54 @@
+import { InstrumentSelector, Liquidity, 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 ask: Liquidity,
+    readonly bid: Liquidity,
+    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.asks = this.ask;
+    orderbook.bids = this.bid;
+
+    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.greaterThanOrEqualTo(0)
+          ? orderbook.bids.rate
+          : orderbook.asks.rate;
+
+        if (rate) {
+          position.calculateEstimatedUnrealizedPnL(rate);
+        }
+      }
+
+      if (quote.total.lessThan(0)) {
+        throw new Error('You have been liquidated.');
+      }
+    }
+
+    changes.commit(orderbook);
+  }
+}

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

@@ -0,0 +1,114 @@
+import { Instrument, Position, PositionMode } from '../domain';
+import { decimal, 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.greaterThanOrEqualTo(0)
+        ? orderbook.bids.rate
+        : orderbook.asks.rate;
+
+      if (rate) {
+        this.position.calculateEstimatedUnrealizedPnL(rate);
+      }
+    }
+  }
+}
+
+export class PositionPatchEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: Instrument,
+    readonly rate: decimal,
+    readonly size: decimal,
+    readonly leverage: number,
+    readonly mode: PositionMode,
+    readonly timestamp: timestamp
+  ) {}
+
+  // eslint-disable-next-line complexity
+  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.equals(0)) {
+      if (position) {
+        position.averageExecutionRate = this.instrument.quote.floor(this.rate);
+        position.size = this.instrument.base.floor(this.size);
+        position.leverage = this.leverage;
+
+        delete balance.position[this.id];
+
+        if (orderbook) {
+          const rate = position.size.greaterThanOrEqualTo(0)
+            ? orderbook.bids.rate
+            : orderbook.asks.rate;
+
+          if (rate) {
+            position.calculateEstimatedUnrealizedPnL(rate);
+          }
+        }
+
+        changes.commit(position);
+        changes.commit(balance);
+      }
+    }
+
+    const size = (position.size = this.instrument.base.floor(this.size));
+    const averageExecutionRate = (position.averageExecutionRate =
+      this.instrument.quote.floor(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.greaterThanOrEqualTo(0)
+        ? orderbook.bids.rate
+        : orderbook.asks.rate;
+
+      if (rate) {
+        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/store-trade.event.spec.ts

@@ -0,0 +1,60 @@
+import { Store } from '..';
+import { Asset, Instrument } from '../domain';
+import { d, now } from '../shared';
+import { TradePatchEvent } from '.';
+
+const instrument = new Instrument(
+  new Asset('btc', 'binance', 8),
+  new Asset('usdt', 'binance', 2),
+  'binance:btc-usdt'
+);
+
+describe('TradePatchEvent', () => {
+  test('should create a new trade object and patch a store', () => {
+    const timestamp = now();
+    const store = new Store();
+
+    store.snapshot.universe.instrument.upsert(instrument);
+    store.snapshot.subscription.instrument.upsert(instrument);
+
+    store.dispatch(new TradePatchEvent(instrument, d(1000), d(0.1), timestamp));
+
+    const trade = store.snapshot.trade.get(instrument.id);
+
+    expect(trade.timestamp).toEqual(timestamp);
+    expect(trade.instrument.id).toEqual(trade.instrument.id);
+    expect(trade.rate).toEqual(d(1000));
+    expect(trade.quantity).toEqual(d(0.1));
+    expect(store.snapshot.timestamp).toEqual(timestamp);
+  });
+
+  test('should use the existing instance of trade when patching a store', () => {
+    const store = new Store();
+    const timestamp = now();
+
+    store.snapshot.universe.instrument.upsert(instrument);
+    store.snapshot.subscription.instrument.upsert(instrument);
+
+    store.dispatch(new TradePatchEvent(instrument, d(1000), d(0.1), timestamp));
+
+    const trade = store.snapshot.trade.get(instrument.id);
+
+    store.dispatch(new TradePatchEvent(instrument, d(2000), d(0.2), timestamp));
+
+    expect(trade.timestamp).toEqual(timestamp);
+    expect(trade.instrument.id).toEqual(instrument.id);
+    expect(trade.rate).toEqual(d(2000));
+    expect(trade.quantity).toEqual(d(0.2));
+    expect(store.snapshot.timestamp).toEqual(timestamp);
+  });
+
+  test('should throw exception when patching unsubscribed instrument', () => {
+    const store = new Store();
+
+    const fn = () => {
+      store.dispatch(new TradePatchEvent(instrument, d(1000), d(0.1), now()));
+    };
+
+    expect(fn).toThrow(Error);
+  });
+});

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

@@ -0,0 +1,36 @@
+import { InstrumentSelector, Trade } from '../domain';
+import { decimal, 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: decimal,
+    readonly quantity: decimal,
+    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.floor(this.rate);
+    trade.quantity = trade.instrument.base.floor(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;
+}