@quantform/core 0.6.6 → 0.7.0-beta.4

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

@@ -1,121 +0,0 @@
-import { Instrument, Position, PositionMode } from '../domain';
-import { decimal, timestamp } from '../shared';
-import { balanceNotFoundError, instrumentNotSubscribedError } from './error';
-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): void {
-    if (!state.subscription.instrument.get(this.position.instrument.id)) {
-      throw instrumentNotSubscribedError(this.position.instrument);
-    }
-
-    this.position.timestamp = this.timestamp;
-
-    const balance = state.balance.get(this.position.instrument.quote.id);
-    if (!balance) {
-      throw 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 instrumentNotSubscribedError(this.instrument);
-    }
-
-    const balance = state.balance.get(this.instrument.quote.id);
-    if (!balance) {
-      throw 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 '../domain';
-import { Set, timestamp } from '../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,62 +0,0 @@
-import { Asset, Commission, Instrument } from '../domain';
-import { d, now } from '../shared';
-import { TradePatchEvent } from '.';
-import { Store } from './store';
-
-const instrument = new Instrument(
-  0,
-  new Asset('btc', 'binance', 8),
-  new Asset('usdt', 'binance', 2),
-  'binance:btc-usdt',
-  Commission.Zero
-);
-
-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) ?? 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,42 +0,0 @@
-import { InstrumentSelector, Trade } from '../domain';
-import { d, decimal, timestamp } from '../shared';
-import { instrumentNotSubscribedError, instrumentNotSupportedError } from './error';
-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 instrumentNotSubscribedError(this.instrument);
-    }
-
-    const instrument = state.universe.instrument.get(this.instrument.id);
-    if (!instrument) {
-      throw 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);
-  }
-}

package/src/store/store.spec.ts

@@ -1,182 +0,0 @@
-import { withLatestFrom } from 'rxjs';
-
-import { Asset, balance, Commission, Instrument, Order, order } from '../domain';
-import { d, now } from '../shared';
-import { Store } from './store';
-import { BalanceTransactEvent } from './store-balance-event';
-import {
-  OrderCanceledEvent,
-  OrderCancelingEvent,
-  OrderFilledEvent,
-  OrderLoadEvent,
-  OrderNewEvent,
-  OrderPendingEvent
-} from './store-order-event';
-
-const instrument = new Instrument(
-  0,
-  new Asset('abc', 'xyz', 4),
-  new Asset('def', 'xyz', 4),
-  'abc-def',
-  Commission.Zero
-);
-
-describe('Store', () => {
-  let store: Store;
-
-  beforeEach(() => {
-    store = new Store();
-  });
-
-  test('should load an existing order and not pipe a changes', () => {
-    let hasUpdatedOrder = false;
-
-    store.changes$.pipe(order(instrument)).subscribe({
-      next: () => {
-        hasUpdatedOrder = true;
-      }
-    });
-
-    store.dispatch(new OrderLoadEvent(new Order(0, '1', instrument, d(10), 0), now()));
-
-    expect(hasUpdatedOrder).toBe(false);
-  });
-
-  test('should create a new order and pipe a changes', () => {
-    let hasUpdatedOrder = false;
-
-    store.changes$.pipe(order(instrument)).subscribe({
-      next: () => {
-        hasUpdatedOrder = true;
-      }
-    });
-
-    store.dispatch(new OrderNewEvent(new Order(0, '1', instrument, d(10), 0), now()));
-
-    expect(hasUpdatedOrder).toBe(true);
-  });
-
-  test('should transition order state from new to pending', () => {
-    const states = ['NEW', 'PENDING'].reverse();
-
-    store.changes$.pipe(order(instrument)).subscribe({
-      next: it => {
-        expect(it.state).toBe(states.pop());
-      }
-    });
-
-    const buyOrder = new Order(0, '1', instrument, d(10), 0);
-
-    store.dispatch(new OrderNewEvent(buyOrder, now()));
-    store.dispatch(new OrderPendingEvent(buyOrder.id, instrument, now()));
-
-    expect(buyOrder.state).toBe('PENDING');
-    expect(states.length).toBe(0);
-  });
-
-  test('should transition order state from new to filled', () => {
-    const states = ['NEW', 'PENDING', 'FILLED'].reverse();
-
-    store.changes$.pipe(order(instrument)).subscribe({
-      next: it => {
-        expect(it.state).toBe(states.pop());
-      }
-    });
-
-    const buyOrder = new Order(0, '1', instrument, d(10), 0);
-
-    store.dispatch(new OrderNewEvent(buyOrder, now()));
-    store.dispatch(new OrderPendingEvent(buyOrder.id, instrument, now()));
-    store.dispatch(new OrderFilledEvent(buyOrder.id, instrument, d(44), now()));
-
-    expect(buyOrder.state).toBe('FILLED');
-    expect(buyOrder.averageExecutionRate).toEqual(d(44));
-    expect(states.length).toBe(0);
-  });
-
-  test('should transition order state from new to canceled', () => {
-    const states = ['NEW', 'PENDING', 'CANCELING', 'CANCELED'].reverse();
-
-    store.changes$.pipe(order(instrument)).subscribe({
-      next: it => {
-        expect(it.state).toBe(states.pop());
-      }
-    });
-
-    const buyOrder = new Order(0, '1', instrument, d(10), 0);
-
-    store.dispatch(new OrderNewEvent(buyOrder, now()));
-    store.dispatch(new OrderPendingEvent(buyOrder.id, instrument, now()));
-    store.dispatch(new OrderCancelingEvent(buyOrder.id, instrument, now()));
-    store.dispatch(new OrderCanceledEvent(buyOrder.id, instrument, now()));
-
-    expect(buyOrder.state).toBe('CANCELED');
-    expect(states.length).toBe(0);
-  });
-
-  test('should patch balance with order and pipe changes once', done => {
-    store.snapshot.universe.instrument.upsert(instrument);
-    store.snapshot.universe.asset.upsert(instrument.quote);
-
-    store.changes$
-      .pipe(
-        balance(instrument.quote, store.snapshot),
-        withLatestFrom(store.changes$.pipe(order(instrument)))
-      )
-      .subscribe({
-        next: ([balance, order]) => {
-          expect(balance.free).toEqual(d(10));
-          expect(order.state).toEqual('PENDING');
-
-          done();
-        }
-      });
-
-    const buyOrder = new Order(0, '1', instrument, d(10), 0);
-
-    store.dispatch(
-      new OrderNewEvent(buyOrder, now()),
-      new OrderPendingEvent(buyOrder.id, instrument, now()),
-      new BalanceTransactEvent(instrument.quote, d(10), now())
-    );
-  });
-
-  test('should pipe balance and order changes', done => {
-    store.snapshot.universe.instrument.upsert(instrument);
-    store.snapshot.universe.asset.upsert(instrument.quote);
-
-    let counter = 2;
-
-    store.changes$.pipe(balance(instrument.quote, store.snapshot)).subscribe({
-      next: it => {
-        counter--;
-
-        expect(it.free).toEqual(d(10));
-
-        if (!counter) {
-          done();
-        }
-      }
-    });
-
-    store.changes$.pipe(order(instrument)).subscribe({
-      next: it => {
-        counter--;
-
-        expect(it.state).toEqual('PENDING');
-
-        if (!counter) {
-          done();
-        }
-      }
-    });
-
-    const buyOrder = new Order(0, '1', instrument, d(10), 0);
-
-    store.dispatch(
-      new OrderNewEvent(buyOrder, now()),
-      new OrderPendingEvent(buyOrder.id, instrument, now()),
-      new BalanceTransactEvent(instrument.quote, d(10), now())
-    );
-  });
-});

package/src/store/store.ts

@@ -1,37 +0,0 @@
-import { Observable, Subject } from 'rxjs';
-
-import { Component } from '../domain';
-import { StoreEvent } from './store-event';
-import { State, StateChangeTracker } from './store-state';
-
-export class Store implements StateChangeTracker {
-  private readonly pendingChanges = new Array<Component>();
-  private readonly changes = new Subject<Component>();
-
-  readonly snapshot = new State();
-
-  get changes$(): Observable<Component> {
-    return this.changes.asObservable();
-  }
-
-  dispatch(...events: StoreEvent[]) {
-    for (const event of events) {
-      event.handle(this.snapshot, this);
-    }
-
-    this.commitPendingChanges();
-  }
-
-  commit(component: Component) {
-    this.pendingChanges.push(component);
-  }
-
-  commitPendingChanges() {
-    this.pendingChanges.forEach(it => this.changes.next(it));
-    this.pendingChanges.splice(0, this.pendingChanges.length);
-  }
-
-  dispose() {
-    this.changes.complete();
-  }
-}

package/dist/{domain → component}/timeframe.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tf = exports.Timeframe = void 0;
 class Timeframe {
 }
-exports.Timeframe = Timeframe;
 Timeframe.S1 = 1000;
 Timeframe.M1 = Timeframe.S1 * 60;
 Timeframe.M5 = Timeframe.M1 * 5;
@@ -15,6 +14,7 @@ Timeframe.H6 = Timeframe.H1 * 6;
 Timeframe.H12 = Timeframe.H6 * 2;
 Timeframe.D1 = Timeframe.H12 * 2;
 Timeframe.W1 = Timeframe.D1 * 7;
+exports.Timeframe = Timeframe;
 function tf(timestamp, timeframe) {
     return timestamp - (timestamp % timeframe);
 }