@quantform/core 0.5.13 → 0.5.23

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

@@ -1,161 +0,0 @@
-import { AssetSelector } from '../../domain/asset';
-import { Balance } from '../../domain/balance';
-import { timestamp } from '../../shared';
-import { event } from '../../shared/topic';
-import { State, StateChangeTracker } from '../store.state';
-import { StoreEvent } from './store.event';
-
-/**
- * Updates the free and freezed balance of the given asset.
- */
-@event
-export class BalancePatchEvent implements StoreEvent {
-  type = 'balance-patch';
-
-  constructor(
-    readonly asset: AssetSelector,
-    readonly free: number,
-    readonly freezed: number,
-    readonly timestamp: timestamp
-  ) {}
-}
-
-/**
- * @see BalancePatchEvent
- */
-export function BalancePatchEventHandler(
-  event: BalancePatchEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  let balance = state.balance[event.asset.toString()];
-
-  if (!balance) {
-    const asset = state.universe.asset[event.asset.toString()];
-
-    if (!asset) {
-      return;
-    }
-
-    balance = state.balance[asset.toString()] = new Balance(asset);
-  }
-
-  balance.timestamp = event.timestamp;
-  balance.set(event.free, event.freezed);
-
-  state.timestamp = event.timestamp;
-
-  changes.commit(balance);
-}
-
-/**
- *
- */
-@event
-export class BalanceTransactEvent implements StoreEvent {
-  type = 'balance-transact';
-
-  constructor(
-    readonly asset: AssetSelector,
-    readonly amount: number,
-    readonly timestamp: timestamp
-  ) {}
-}
-
-/**
- * @see BalanceTransactEvent
- */
-export function BalanceTransactEventHandler(
-  event: BalanceTransactEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  let balance = state.balance[event.asset.toString()];
-
-  if (!balance) {
-    const asset = state.universe.asset[event.asset.toString()];
-
-    balance = new Balance(asset);
-
-    state.balance[asset.toString()] = balance;
-  }
-
-  balance.timestamp = event.timestamp;
-  balance.transact(event.amount);
-
-  state.timestamp = event.timestamp;
-
-  changes.commit(balance);
-}
-
-/**
- *
- */
-@event
-export class BalanceFreezEvent implements StoreEvent {
-  type = 'balance-freez';
-
-  constructor(
-    readonly asset: AssetSelector,
-    readonly amount: number,
-    readonly timestamp: timestamp
-  ) {}
-}
-
-/**
- * @see BalanceFreezEvent
- */
-export function BalanceFreezEventHandler(
-  event: BalanceFreezEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  const balance = state.balance[event.asset.toString()];
-
-  if (!balance) {
-    throw new Error('invalid balance');
-  }
-
-  balance.timestamp = event.timestamp;
-  balance.freez(event.amount);
-
-  state.timestamp = event.timestamp;
-
-  changes.commit(balance);
-}
-
-/**
- *
- */
-@event
-export class BalanceUnfreezEvent implements StoreEvent {
-  type = 'balance-unfreez';
-
-  constructor(
-    readonly asset: AssetSelector,
-    readonly amount: number,
-    readonly timestamp: timestamp
-  ) {}
-}
-
-/**
- * @see BalanceUnfreezEvent
- */
-export function BalanceUnfreezEventHandler(
-  event: BalanceUnfreezEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  const balance = state.balance[event.asset.toString()];
-
-  if (!balance) {
-    throw new Error('invalid balance');
-  }
-
-  balance.timestamp = event.timestamp;
-  balance.unfreez(event.amount);
-
-  state.timestamp = event.timestamp;
-
-  changes.commit(balance);
-}

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

@@ -1,30 +0,0 @@
-import { Asset, Instrument } from '../../domain';
-import { now } from '../../shared';
-import { Store } from '../store';
-import { CandleEvent } from '.';
-
-const instrument = new Instrument(
-  new Asset('btc', 'binance', 8),
-  new Asset('usdt', 'binance', 2),
-  'binance:btc-usdt'
-);
-
-describe('candle patch event tests', () => {
-  test('should patch trade object', () => {
-    const timestamp = now();
-    const store = new Store();
-
-    store.snapshot.universe.instrument[instrument.toString()] = instrument;
-    store.snapshot.subscription.instrument[instrument.toString()] = instrument;
-
-    store.dispatch(new CandleEvent(instrument, 1, 1, 1, 1, 1, 1, timestamp));
-
-    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(store.snapshot.timestamp).toEqual(timestamp);
-  });
-});

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

@@ -1,71 +0,0 @@
-import { InstrumentSelector } from '../../domain';
-import { timestamp } from '../../shared/datetime';
-import { event } from '../../shared/topic';
-import { StateChangeTracker } from '..';
-import { State } from '../store.state';
-import { StoreEvent } from './store.event';
-import { OrderbookPatchEventHandler } from './store-orderbook.event';
-import { TradePatchEventHandler } from './store-trade.event';
-
-@event
-export class CandleEvent implements StoreEvent {
-  type = 'candle';
-
-  constructor(
-    readonly instrument: InstrumentSelector,
-    readonly timeframe: number,
-    readonly open: number,
-    readonly high: number,
-    readonly low: number,
-    readonly close: number,
-    readonly volume: number,
-    readonly timestamp: timestamp
-  ) {}
-}
-
-export function CandleEventHandler(
-  event: CandleEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  const instrument = state.universe.instrument[event.instrument.toString()];
-
-  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.spec.ts

@@ -1,25 +0,0 @@
-import { Asset, Commission } from '../../domain';
-import { now } from '../../shared';
-import { Store } from '..';
-import { InstrumentPatchEvent } from './store-instrument.event';
-
-describe('instrument patch event tests', () => {
-  test('should patch a store', () => {
-    const timestamp = now();
-    const store = new Store();
-    const base = new Asset('de30', 'cex', 2);
-    const quote = new Asset('usd', 'cex', 2);
-
-    store.dispatch(
-      new InstrumentPatchEvent(timestamp, base, quote, new Commission(0, 0), '')
-    );
-
-    expect(store.snapshot.universe.instrument['cex:de30-usd'].base).toEqual(base);
-    expect(store.snapshot.universe.instrument['cex:de30-usd'].quote).toEqual(quote);
-    expect(store.snapshot.universe.instrument['cex:de30-usd'].timestamp).toEqual(
-      timestamp
-    );
-    expect(Object.keys(store.snapshot.universe.instrument).length).toEqual(1);
-    expect(Object.keys(store.snapshot.universe.asset).length).toEqual(2);
-  });
-});

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

@@ -1,84 +0,0 @@
-import { Asset, Commission } from '../../domain';
-import { Instrument, InstrumentSelector } from '../../domain/instrument';
-import { timestamp } from '../../shared';
-import { event } from '../../shared/topic';
-import { State, StateChangeTracker } from '../../store';
-import { StoreEvent } from './store.event';
-
-@event
-export class InstrumentPatchEvent implements StoreEvent {
-  type = 'instrument-patch';
-
-  constructor(
-    readonly timestamp: timestamp,
-    readonly base: Asset,
-    readonly quote: Asset,
-    readonly commission: Commission,
-    readonly raw: string,
-    readonly leverage?: number
-  ) {}
-}
-
-export function InstrumentPatchEventHandler(
-  event: InstrumentPatchEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  const selector = new InstrumentSelector(
-    event.base.name,
-    event.quote.name,
-    event.base.adapter
-  );
-
-  let instrument = state.universe.instrument[selector.toString()];
-  if (!instrument) {
-    instrument = new Instrument(event.base, event.quote, event.raw);
-
-    //TODO: add asset before
-    state.universe.asset[event.base.toString()] = event.base;
-    state.universe.asset[event.quote.toString()] = event.quote;
-    state.universe.instrument[selector.toString()] = instrument;
-  }
-
-  instrument.timestamp = event.timestamp;
-  instrument.commission = event.commission;
-
-  if (event.leverage) {
-    instrument.leverage = event.leverage;
-  }
-
-  changes.commit(instrument);
-}
-
-@event
-export class InstrumentSubscriptionEvent implements StoreEvent {
-  type = 'instrument-subscription';
-
-  constructor(
-    readonly timestamp: timestamp,
-    readonly instrument: InstrumentSelector,
-    readonly subscribed: boolean
-  ) {}
-}
-
-export function InstrumentSubscriptionEventHandler(
-  event: InstrumentSubscriptionEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  const instrumentKey = event.instrument.toString();
-
-  if (!(instrumentKey in state.universe.instrument)) {
-    throw new Error(`Trying to patch not existing instrument: ${instrumentKey}`);
-  }
-
-  const instrument = state.universe.instrument[instrumentKey];
-
-  if (event.subscribed) {
-    state.subscription.instrument[instrument.toString()] = instrument;
-    state.subscription.asset[instrument.base.toString()] = instrument.base;
-    state.subscription.asset[instrument.quote.toString()] = instrument.quote;
-  }
-
-  changes.commit(instrument);
-}

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

@@ -1,28 +0,0 @@
-import { Asset, Instrument, Order } from '../../domain';
-import { now } from '../../shared';
-import { Store } from '../store';
-import { OrderLoadEvent } from './store-order.event';
-
-const instrument = new Instrument(
-  new Asset('btc', 'binance', 8),
-  new Asset('usdt', 'binance', 2),
-  'binance:btc-usdt'
-);
-
-describe('order load event tests', () => {
-  test('should load order to store', () => {
-    const timestamp = now();
-    const store = new Store();
-    const order = Order.buyMarket(instrument, 1.0);
-
-    order.state = 'PENDING';
-
-    store.snapshot.universe.instrument[instrument.toString()] = instrument;
-    store.snapshot.subscription.instrument[instrument.toString()] = instrument;
-
-    store.dispatch(new OrderLoadEvent(order, timestamp));
-
-    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,218 +0,0 @@
-import { Order } from '../../domain';
-import { timestamp } from '../../shared';
-import { event } from '../../shared/topic';
-import { State, StateChangeTracker } from '../store.state';
-import { StoreEvent } from './store.event';
-
-@event
-export class OrderLoadEvent implements StoreEvent {
-  type = 'order-load';
-
-  constructor(readonly order: Order, readonly timestamp: timestamp) {}
-}
-
-export function OrderLoadEventHandler(
-  event: OrderLoadEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  event.order.timestamp = event.timestamp;
-
-  state.order[event.order.id] = event.order;
-
-  changes.commit(event.order);
-}
-
-@event
-export class OrderNewEvent implements StoreEvent {
-  type = 'order-new';
-
-  constructor(readonly order: Order, readonly timestamp: timestamp) {}
-}
-
-export function OrderNewEventHandler(
-  event: OrderNewEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  if (event.order.state != 'NEW') {
-    throw new Error(`Order is not new`);
-  }
-
-  event.order.createdAt = event.timestamp;
-  event.order.timestamp = event.timestamp;
-
-  state.order[event.order.id] = event.order;
-
-  changes.commit(event.order);
-}
-
-@event
-export class OrderPendingEvent implements StoreEvent {
-  type = 'order-pending';
-
-  constructor(readonly id: string, readonly timestamp: timestamp) {}
-}
-
-export function OrderPendingEventHandler(
-  event: OrderPendingEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  if (!(event.id in state.order)) {
-    throw new Error(`Trying to patch unknown order: ${event.id}`);
-  }
-
-  const order = state.order[event.id];
-
-  if (order.state != 'NEW') {
-    throw new Error(`Order is not NEW: ${order.state}`);
-  }
-
-  order.state = 'PENDING';
-  order.timestamp = event.timestamp;
-
-  changes.commit(order);
-}
-
-@event
-export class OrderFilledEvent implements StoreEvent {
-  type = 'order-filled';
-
-  constructor(
-    readonly id: string,
-    readonly averageExecutionRate: number,
-    readonly timestamp: timestamp
-  ) {}
-}
-
-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[event.id];
-
-  if (order.state != 'PENDING' && order.state != 'CANCELING') {
-    throw new Error(`Order is not PENDING or CANCELING: ${order.state}`);
-  }
-
-  order.state = 'FILLED';
-  order.timestamp = event.timestamp;
-  order.quantityExecuted = order.quantity;
-  order.averageExecutionRate = event.averageExecutionRate;
-
-  changes.commit(order);
-}
-
-@event
-export class OrderCancelingEvent implements StoreEvent {
-  type = 'order-canceling';
-
-  constructor(readonly id: string, readonly timestamp: timestamp) {}
-}
-
-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[event.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 = event.timestamp;
-
-  changes.commit(order);
-}
-
-@event
-export class OrderCanceledEvent implements StoreEvent {
-  type = 'order-canceled';
-
-  constructor(readonly id: string, readonly timestamp: timestamp) {}
-}
-
-export function OrderCanceledEventHandler(
-  event: OrderCanceledEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  const order = state.order[event.id];
-
-  if (order.state == 'CANCELED') {
-    return;
-  }
-
-  if (order.state != 'CANCELING') {
-    throw new Error(`Order is not CANCELING: ${order.state}`);
-  }
-
-  order.state = 'CANCELED';
-  order.timestamp = event.timestamp;
-
-  changes.commit(order);
-}
-
-@event
-export class OrderCancelFailedEvent implements StoreEvent {
-  type = 'order-cancel-failed';
-
-  constructor(readonly id: string, readonly timestamp: timestamp) {}
-}
-
-export function OrderCancelFailedEventHandler(
-  event: OrderCancelFailedEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  const order = state.order[event.id];
-
-  if (order.state != 'CANCELING') {
-    return;
-  }
-
-  order.state = 'PENDING';
-  order.timestamp = event.timestamp;
-
-  changes.commit(order);
-}
-
-@event
-export class OrderRejectedEvent implements StoreEvent {
-  type = 'order-canceled';
-
-  constructor(readonly id: string, readonly timestamp: timestamp) {}
-}
-
-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: ${order.state}`);
-  }
-
-  order.state = 'REJECTED';
-  order.timestamp = event.timestamp;
-
-  changes.commit(order);
-}

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

@@ -1,70 +0,0 @@
-import { InstrumentSelector } from '../../domain/instrument';
-import { Orderbook } from '../../domain/orderbook';
-import { timestamp } from '../../shared';
-import { event } from '../../shared/topic';
-import { State, StateChangeTracker } from '../store.state';
-import { StoreEvent } from './store.event';
-
-@event
-export class OrderbookPatchEvent implements StoreEvent {
-  type = 'orderbook-patch';
-
-  constructor(
-    readonly instrument: InstrumentSelector,
-    readonly bestAskRate: number,
-    readonly bestAskQuantity: number,
-    readonly bestBidRate: number,
-    readonly bestBidQuantity: number,
-    readonly timestamp: timestamp
-  ) {}
-}
-
-export function OrderbookPatchEventHandler(
-  event: OrderbookPatchEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  const instrumentKey = event.instrument.toString();
-
-  if (!(instrumentKey in state.subscription.instrument)) {
-    throw new Error(`Trying to patch unsubscribed instrument: ${instrumentKey}`);
-  }
-
-  let orderbook = state.orderbook[instrumentKey];
-
-  if (!orderbook) {
-    const instrument = state.universe.instrument[instrumentKey];
-
-    orderbook = new Orderbook(instrument);
-
-    state.orderbook[instrumentKey] = orderbook;
-  }
-
-  state.timestamp = event.timestamp;
-
-  orderbook.timestamp = event.timestamp;
-  orderbook.bestAskRate = orderbook.instrument.quote.fixed(event.bestAskRate);
-  orderbook.bestAskQuantity = orderbook.instrument.base.fixed(event.bestAskQuantity);
-  orderbook.bestBidRate = orderbook.instrument.quote.fixed(event.bestBidRate);
-  orderbook.bestBidQuantity = orderbook.instrument.base.fixed(event.bestBidQuantity);
-
-  const quote = state.balance[orderbook.instrument.quote.toString()];
-
-  if (quote) {
-    for (const position of Object.values(quote.position)) {
-      if (position.instrument.toString() != orderbook.toString()) {
-        continue;
-      }
-
-      const rate = position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
-
-      position.calculatePnL(rate);
-    }
-
-    if (quote.total < 0) {
-      throw new Error('liquidated');
-    }
-  }
-
-  changes.commit(orderbook);
-}