@quantform/core 0.6.6 → 0.7.0-beta.4

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

@@ -1,167 +0,0 @@
-import { AssetSelector, Balance, InstrumentSelector } from '../domain';
-import { decimal, timestamp } from '../shared';
-import {
-  assetNotSupportedError,
-  balanceNotFoundError,
-  instrumentNotSubscribedError,
-  orderNotFoundError
-} from './error';
-import { StoreEvent } from './store-event';
-import { State, StateChangeTracker } from './store-state';
-
-/**
- * Updates the free and freezed balance of the given asset.
- */
-export class BalancePatchEvent implements StoreEvent {
-  constructor(
-    readonly asset: AssetSelector,
-    readonly free: decimal,
-    readonly freezed: decimal,
-    readonly timestamp: timestamp
-  ) {}
-
-  handle(state: State, changes: StateChangeTracker) {
-    /*
-     * skip not tradeable assets (for example, you can have an unlisted
-     * asset in your wallet).
-     */
-    const asset = state.universe.asset.get(this.asset.id);
-    if (!asset) {
-      return;
-    }
-
-    const balance = state.balance.tryGetOrSet(this.asset.id, () => new Balance(0, asset));
-
-    balance.timestamp = this.timestamp;
-    balance.set(this.free, this.freezed);
-
-    state.timestamp = this.timestamp;
-
-    changes.commit(balance);
-  }
-}
-
-/**
- *
- */
-export class BalanceTransactEvent implements StoreEvent {
-  constructor(
-    readonly asset: AssetSelector,
-    readonly amount: decimal,
-    readonly timestamp: timestamp
-  ) {}
-
-  handle(state: State, changes: StateChangeTracker) {
-    const asset = state.universe.asset.get(this.asset.id);
-    if (!asset) {
-      throw assetNotSupportedError(this.asset);
-    }
-
-    const balance = state.balance.tryGetOrSet(this.asset.id, () => new Balance(0, asset));
-
-    balance.timestamp = this.timestamp;
-    balance.account(this.amount);
-
-    state.timestamp = this.timestamp;
-
-    changes.commit(balance);
-  }
-}
-
-/**
- *
- */
-export class BalanceLockOrderEvent implements StoreEvent {
-  constructor(
-    readonly orderId: string,
-    readonly instrument: InstrumentSelector,
-    readonly timestamp: timestamp
-  ) {}
-
-  handle(state: State, changes: StateChangeTracker) {
-    const orders = state.order.get(this.instrument.id);
-    if (!orders) {
-      throw instrumentNotSubscribedError(this.instrument);
-    }
-
-    const order = orders.get(this.orderId);
-    if (!order) {
-      throw orderNotFoundError(this.orderId);
-    }
-
-    const base = state.balance.get(order.instrument.base.id);
-    if (!base) {
-      throw balanceNotFoundError(order.instrument.base);
-    }
-
-    const quote = state.balance.get(order.instrument.quote.id);
-    if (!quote) {
-      throw balanceNotFoundError(order.instrument.quote);
-    }
-
-    const balanceToLock = order.calculateBalanceToLock(base, quote);
-
-    state.timestamp = this.timestamp;
-
-    if (balanceToLock.base?.greaterThan(0)) {
-      base.timestamp = this.timestamp;
-      base.lock(this.orderId, balanceToLock.base);
-
-      changes.commit(base);
-    }
-
-    if (balanceToLock.quote?.greaterThan(0)) {
-      quote.timestamp = this.timestamp;
-      quote.lock(this.orderId, balanceToLock.quote);
-
-      changes.commit(quote);
-    }
-  }
-}
-
-/**
- *
- */
-export class BalanceUnlockOrderEvent implements StoreEvent {
-  constructor(
-    readonly orderId: string,
-    readonly instrument: InstrumentSelector,
-    readonly timestamp: timestamp
-  ) {}
-
-  handle(state: State, changes: StateChangeTracker) {
-    const orders = state.order.get(this.instrument.id);
-    if (!orders) {
-      throw instrumentNotSubscribedError(this.instrument);
-    }
-
-    const order = orders.get(this.orderId);
-    if (!order) {
-      throw orderNotFoundError(this.orderId);
-    }
-
-    const base = state.balance.get(order.instrument.base.id);
-    if (!base) {
-      throw balanceNotFoundError(order.instrument.base);
-    }
-
-    const quote = state.balance.get(order.instrument.quote.id);
-    if (!quote) {
-      throw balanceNotFoundError(order.instrument.quote);
-    }
-
-    state.timestamp = this.timestamp;
-
-    if (base.tryUnlock(this.orderId)) {
-      base.timestamp = this.timestamp;
-
-      changes.commit(base);
-    }
-
-    if (quote.tryUnlock(this.orderId)) {
-      quote.timestamp = this.timestamp;
-
-      changes.commit(quote);
-    }
-  }
-}

package/src/store/store-event.ts

@@ -1,8 +0,0 @@
-import { timestamp } from '../shared';
-import { State, StateChangeTracker } from './store-state';
-
-export interface StoreEvent {
-  timestamp: timestamp;
-
-  handle(state: State, changes: StateChangeTracker): void;
-}

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

@@ -1,26 +0,0 @@
-import { Asset, Commission } from '../domain';
-import { d, now } from '../shared';
-import { Store } from './store';
-import { InstrumentPatchEvent } from './store-instrument-event';
-
-describe('InstrumentPatchEvent', () => {
-  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(d.Zero, d.Zero), '')
-    );
-
-    const { universe } = store.snapshot;
-    const instrument = universe.instrument.get('cex:de30-usd') ?? fail();
-
-    expect(instrument.base).toEqual(base);
-    expect(instrument.quote).toEqual(quote);
-    expect(instrument.timestamp).toEqual(timestamp);
-    expect(universe.instrument.asReadonlyArray().length).toEqual(1);
-    expect(universe.asset.asReadonlyArray().length).toEqual(2);
-  });
-});

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

@@ -1,83 +0,0 @@
-import { Asset, Commission, Instrument, InstrumentSelector } from '../domain';
-import { timestamp } from '../shared';
-import { State, StateChangeTracker } from '.';
-import { assetNotSupportedError, instrumentNotSupportedError } from './error';
-import { StoreEvent } from './store-event';
-import { InnerSet } from './store-state';
-
-export class InstrumentPatchEvent implements StoreEvent {
-  constructor(
-    readonly timestamp: timestamp,
-    readonly base: Asset,
-    readonly quote: Asset,
-    readonly commission: Commission,
-    readonly raw: string,
-    readonly leverage?: number
-  ) {}
-
-  handle(state: State, changes: StateChangeTracker): void {
-    const selector = new InstrumentSelector(
-      this.base.name,
-      this.quote.name,
-      this.base.adapterName
-    );
-
-    const instrument = state.universe.instrument.tryGetOrSet(selector.id, () => {
-      state.universe.asset.tryGetOrSet(
-        this.base.id,
-        () => new Asset(this.base.name, this.base.adapterName, 8)
-      );
-
-      state.universe.asset.tryGetOrSet(
-        this.quote.id,
-        () => new Asset(this.quote.name, this.quote.adapterName, 8)
-      );
-
-      state.order.tryGetOrSet(selector.id, () => new InnerSet(selector.id));
-
-      return new Instrument(0, this.base, this.quote, this.raw, Commission.Zero);
-    });
-
-    instrument.timestamp = this.timestamp;
-    instrument.commission = this.commission;
-
-    if (this.leverage) {
-      instrument.leverage = this.leverage;
-    }
-
-    changes.commit(instrument);
-  }
-}
-
-export class InstrumentSubscriptionEvent implements StoreEvent {
-  constructor(
-    readonly timestamp: timestamp,
-    readonly instrument: InstrumentSelector,
-    readonly subscribed: boolean
-  ) {}
-
-  handle(state: State, changes: StateChangeTracker): void {
-    const instrument = state.universe.instrument.get(this.instrument.id);
-    if (!instrument) {
-      throw instrumentNotSupportedError(this.instrument);
-    }
-
-    if (this.subscribed) {
-      const base = state.universe.asset.get(instrument.base.id);
-      if (!base) {
-        throw assetNotSupportedError(instrument.base);
-      }
-
-      const quote = state.universe.asset.get(instrument.quote.id);
-      if (!quote) {
-        throw assetNotSupportedError(instrument.quote);
-      }
-
-      state.subscription.instrument.upsert(instrument);
-      state.subscription.asset.upsert(base);
-      state.subscription.asset.upsert(quote);
-    }
-
-    changes.commit(instrument);
-  }
-}

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

@@ -1,32 +0,0 @@
-import { Asset, Commission, Instrument, Order } from '../domain';
-import { d, now } from '../shared';
-import { Store } from '.';
-import { OrderLoadEvent } from './store-order-event';
-
-describe('OrderLoadEvent', () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('btc', 'binance', 8),
-    new Asset('usdt', 'binance', 2),
-    'binance:btc-usdt',
-    Commission.Zero
-  );
-
-  test('should load order to store', () => {
-    const timestamp = now();
-    const store = new Store();
-    const order = new Order(0, '1', instrument, d(1.0), 0);
-
-    order.state = 'PENDING';
-
-    store.snapshot.universe.instrument.upsert(instrument);
-    store.snapshot.subscription.instrument.upsert(instrument);
-
-    store.dispatch(new OrderLoadEvent(order, timestamp));
-
-    const pendingOrder = store.snapshot.order.get(instrument.id)?.get('1') ?? fail();
-
-    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(pendingOrder).toEqual(order);
-  });
-});

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

@@ -1,219 +0,0 @@
-import { InstrumentSelector, Order } from '../domain';
-import { decimal, timestamp } from '../shared';
-import { orderInvalidStateError, orderNotFoundError } from './error';
-import { StoreEvent } from './store-event';
-import { InnerSet, State, StateChangeTracker } from './store-state';
-
-/**
- * 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 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);
-
-    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 orderNotFoundError(this.id);
-      })
-      .tryGetOrSet(this.id, () => {
-        throw orderNotFoundError(this.id);
-      });
-
-    if (order.state != 'NEW') {
-      throw 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 orderNotFoundError(this.id);
-      })
-      .tryGetOrSet(this.id, () => {
-        throw orderNotFoundError(this.id);
-      });
-
-    if (order.state != 'PENDING' && order.state != 'CANCELING') {
-      throw 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 orderNotFoundError(this.id);
-      })
-      .tryGetOrSet(this.id, () => {
-        throw orderNotFoundError(this.id);
-      });
-
-    if (order.state == 'CANCELING' || order.state == 'CANCELED') {
-      return;
-    }
-
-    if (order.state != 'PENDING') {
-      throw 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 orderNotFoundError(this.id);
-      })
-      .tryGetOrSet(this.id, () => {
-        throw orderNotFoundError(this.id);
-      });
-
-    if (order.state == 'CANCELED') {
-      return;
-    }
-
-    if (order.state != 'CANCELING') {
-      throw orderInvalidStateError(order.state, ['CANCELING']);
-    }
-
-    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 orderNotFoundError(this.id);
-      })
-      .tryGetOrSet(this.id, () => {
-        throw 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 orderNotFoundError(this.id);
-      })
-      .tryGetOrSet(this.id, () => {
-        throw orderNotFoundError(this.id);
-      });
-
-    if (order.state != 'NEW') {
-      throw orderInvalidStateError(order.state, ['NEW']);
-    }
-
-    order.state = 'REJECTED';
-    order.timestamp = this.timestamp;
-
-    changes.commit(order);
-  }
-}

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

@@ -1,39 +0,0 @@
-import { Asset, Commission, Instrument, Liquidity } from '../domain';
-import { d, now } from '../shared';
-import { OrderbookPatchEvent } from '.';
-import { Store } from './store';
-
-describe('OrderbookPatchEvent', () => {
-  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,56 +0,0 @@
-import { InstrumentSelector, Liquidity, Orderbook } from '../domain';
-import { timestamp } from '../shared';
-import { instrumentNotSupportedError, liquidationError } from './error';
-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 {
-    const instrument = state.universe.instrument.get(this.instrument.id);
-    if (!instrument) {
-      throw 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 liquidationError();
-      }
-    }
-
-    changes.commit(orderbook);
-  }
-}