@quantform/core 0.6.7 → 0.7.0-beta.5

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

@@ -1,288 +0,0 @@
-import { InstrumentSelector, Order } from '@lib/domain';
-import { decimal, timestamp } from '@lib/shared';
-import {
-  BalanceNotFoundError,
-  InnerSet,
-  OrderInvalidStateError,
-  OrderNotFoundError,
-  State,
-  StateChangeTracker,
-  StoreEvent
-} from '@lib/store';
-
-/**
- * Patches a store with an existing pending order.
- * No store changing events are propagated.
- */
-export class OrderLoadEvent implements StoreEvent {
-  constructor(readonly order: Order, readonly timestamp: timestamp) {}
-
-  handle(state: State): 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 OrderInvalidStateError(this.order.state, ['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);
-
-    const base = state.balance.get(this.order.instrument.base.id);
-    const quote = state.balance.get(this.order.instrument.quote.id);
-
-    if (!base || !quote) {
-      throw new BalanceNotFoundError(
-        !base ? this.order.instrument.base : this.order.instrument.quote
-      );
-    }
-
-    if (base.tryAddTransientFunding(this.order)) {
-      base.timestamp = this.timestamp;
-
-      changes.commit(base);
-    }
-
-    if (quote.tryAddTransientFunding(this.order)) {
-      quote.timestamp = this.timestamp;
-
-      changes.commit(quote);
-    }
-
-    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 OrderNotFoundError(this.id);
-      })
-      .tryGetOrSet(this.id, () => {
-        throw new OrderNotFoundError(this.id);
-      });
-
-    if (order.state != 'NEW') {
-      throw new OrderInvalidStateError(order.state, ['NEW']);
-    }
-
-    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 OrderNotFoundError(this.id);
-      })
-      .tryGetOrSet(this.id, () => {
-        throw new OrderNotFoundError(this.id);
-      });
-
-    if (order.state != 'PENDING' && order.state != 'CANCELING') {
-      throw new OrderInvalidStateError(order.state, ['PENDING', 'CANCELING']);
-    }
-
-    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 OrderNotFoundError(this.id);
-      })
-      .tryGetOrSet(this.id, () => {
-        throw new OrderNotFoundError(this.id);
-      });
-
-    if (order.state == 'CANCELING' || order.state == 'CANCELED') {
-      return;
-    }
-
-    if (order.state != 'PENDING') {
-      throw new OrderInvalidStateError(order.state, ['PENDING']);
-    }
-
-    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 OrderNotFoundError(this.id);
-      })
-      .tryGetOrSet(this.id, () => {
-        throw new OrderNotFoundError(this.id);
-      });
-
-    if (order.state == 'CANCELED') {
-      return;
-    }
-
-    if (order.state != 'CANCELING') {
-      throw new OrderInvalidStateError(order.state, ['CANCELING']);
-    }
-
-    order.state = 'CANCELED';
-    order.timestamp = this.timestamp;
-
-    const base = state.balance.get(order.instrument.base.id);
-    const quote = state.balance.get(order.instrument.quote.id);
-
-    if (!base || !quote) {
-      throw new BalanceNotFoundError(
-        !base ? order.instrument.base : order.instrument.quote
-      );
-    }
-
-    if (base.tryRemoveTransientFunding(order)) {
-      base.timestamp = this.timestamp;
-
-      changes.commit(base);
-    }
-
-    if (quote.tryRemoveTransientFunding(order)) {
-      quote.timestamp = this.timestamp;
-
-      changes.commit(quote);
-    }
-
-    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 OrderNotFoundError(this.id);
-      })
-      .tryGetOrSet(this.id, () => {
-        throw new OrderNotFoundError(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 OrderNotFoundError(this.id);
-      })
-      .tryGetOrSet(this.id, () => {
-        throw new OrderNotFoundError(this.id);
-      });
-
-    if (order.state != 'NEW') {
-      throw new OrderInvalidStateError(order.state, ['NEW']);
-    }
-
-    order.state = 'REJECTED';
-    order.timestamp = this.timestamp;
-
-    const base = state.balance.get(order.instrument.base.id);
-    const quote = state.balance.get(order.instrument.quote.id);
-
-    if (!base || !quote) {
-      throw new BalanceNotFoundError(
-        !base ? order.instrument.base : order.instrument.quote
-      );
-    }
-
-    if (base.tryRemoveTransientFunding(order)) {
-      base.timestamp = this.timestamp;
-
-      changes.commit(base);
-    }
-
-    if (quote.tryRemoveTransientFunding(order)) {
-      quote.timestamp = this.timestamp;
-
-      changes.commit(quote);
-    }
-
-    changes.commit(order);
-  }
-}

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

@@ -1,38 +0,0 @@
-import { Asset, Commission, Instrument, Liquidity } from '@lib/domain';
-import { d, now } from '@lib/shared';
-import { OrderbookPatchEvent, Store } from '@lib/store';
-
-describe(OrderbookPatchEvent.name, () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('btc', 'binance', 8),
-    new Asset('usdt', 'binance', 2),
-    'binance:btc-usdt',
-    Commission.Zero
-  );
-
-  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) ?? fail();
-
-    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

@@ -1,60 +0,0 @@
-import { InstrumentSelector, Liquidity, Orderbook } from '@lib/domain';
-import { timestamp } from '@lib/shared';
-import {
-  InstrumentNotSupportedError,
-  LiquidationError,
-  State,
-  StateChangeTracker,
-  StoreEvent
-} from '@lib/store';
-
-export class OrderbookPatchEvent implements StoreEvent {
-  constructor(
-    readonly instrument: InstrumentSelector,
-    readonly ask: Liquidity,
-    readonly bid: Liquidity,
-    readonly timestamp: timestamp
-  ) {}
-
-  handle(state: State, changes: StateChangeTracker): void {
-    const instrument = state.universe.instrument.get(this.instrument.id);
-    if (!instrument) {
-      throw new InstrumentNotSupportedError(this.instrument);
-    }
-
-    const orderbook = state.orderbook.tryGetOrSet(
-      this.instrument.id,
-      () => new Orderbook(0, instrument, this.ask, this.bid)
-    );
-
-    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 LiquidationError();
-      }
-    }
-
-    changes.commit(orderbook);
-  }
-}

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

@@ -1,125 +0,0 @@
-import { Instrument, Position, PositionMode } from '@lib/domain';
-import { decimal, timestamp } from '@lib/shared';
-import {
-  BalanceNotFoundError,
-  InstrumentNotSubscribedError,
-  State,
-  StateChangeTracker,
-  StoreEvent
-} from '@lib/store';
-
-export class PositionLoadEvent implements StoreEvent {
-  constructor(readonly position: Position, readonly timestamp: timestamp) {}
-
-  handle(state: State): void {
-    if (!state.subscription.instrument.get(this.position.instrument.id)) {
-      throw new InstrumentNotSubscribedError(this.position.instrument);
-    }
-
-    this.position.timestamp = this.timestamp;
-
-    const balance = state.balance.get(this.position.instrument.quote.id);
-    if (!balance) {
-      throw new BalanceNotFoundError(this.position.instrument.quote);
-    }
-
-    balance.position[this.position.id] = this.position;
-
-    const orderbook = state.orderbook.get(this.position.instrument.id);
-    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 InstrumentNotSubscribedError(this.instrument);
-    }
-
-    const balance = state.balance.get(this.instrument.quote.id);
-    if (!balance) {
-      throw new BalanceNotFoundError(this.instrument.quote);
-    }
-
-    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.timestamp,
-        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

@@ -1,48 +0,0 @@
-import {
-  Asset,
-  AssetSelector,
-  Balance,
-  Component,
-  Instrument,
-  InstrumentSelector,
-  Order,
-  Orderbook,
-  Trade
-} from '@lib/domain';
-import { Set, timestamp } from '@lib/shared';
-
-export interface StateChangeTracker {
-  commit(component: Component): void;
-  commitPendingChanges(): void;
-}
-
-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 = 0;
-
-  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

@@ -1,61 +0,0 @@
-import { Asset, Commission, Instrument } from '@lib/domain';
-import { d, now } from '@lib/shared';
-import { Store, TradePatchEvent } from '@lib/store';
-
-const instrument = new Instrument(
-  0,
-  new Asset('btc', 'binance', 8),
-  new Asset('usdt', 'binance', 2),
-  'binance:btc-usdt',
-  Commission.Zero
-);
-
-describe(TradePatchEvent.name, () => {
-  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) ?? fail();
-
-    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) ?? fail();
-
-    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

@@ -1,46 +0,0 @@
-import { InstrumentSelector, Trade } from '@lib/domain';
-import { d, decimal, timestamp } from '@lib/shared';
-import {
-  InstrumentNotSubscribedError,
-  InstrumentNotSupportedError,
-  State,
-  StateChangeTracker,
-  StoreEvent
-} from '@lib/store';
-
-/**
- * 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 InstrumentNotSubscribedError(this.instrument);
-    }
-
-    const instrument = state.universe.instrument.get(this.instrument.id);
-    if (!instrument) {
-      throw new InstrumentNotSupportedError(this.instrument);
-    }
-
-    const trade = state.trade.tryGetOrSet(
-      this.instrument.id,
-      () => new Trade(0, instrument, d.Zero, d.Zero)
-    );
-
-    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);
-  }
-}