@quantform/core 0.5.13 → 0.5.23

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

@@ -1,109 +0,0 @@
-import { Instrument, Position, PositionMode } 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 PositionLoadEvent implements StoreEvent {
-  type = 'position-load';
-
-  constructor(readonly position: Position, readonly timestamp: timestamp) {}
-}
-
-export function PositionLoadEventHandler(
-  event: PositionLoadEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  if (
-    event.position.instrument.toString()! in state.subscription.instrument ||
-    event.position.size == 0
-  ) {
-    return;
-  }
-
-  event.position.timestamp = event.timestamp;
-
-  const balance = state.balance[event.position.instrument.quote.toString()];
-  const orderbook = state.orderbook[event.position.instrument.toString()];
-
-  balance.position[event.position.toString()] = event.position;
-
-  if (orderbook) {
-    const rate = event.position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
-
-    event.position.calculatePnL(rate);
-  }
-
-  return event.position;
-}
-
-@event
-export class PositionPatchEvent implements StoreEvent {
-  type = 'position-patch';
-
-  constructor(
-    readonly id: string,
-    readonly instrument: Instrument,
-    readonly rate: number,
-    readonly size: number,
-    readonly leverage: number,
-    readonly mode: PositionMode,
-    readonly timestamp: timestamp
-  ) {}
-}
-
-export function PositionPatchEventHandler(
-  event: PositionPatchEvent,
-  state: State,
-  changes: StateChangeTracker
-) {
-  if (!(event.instrument.toString() in state.subscription.instrument)) {
-    return;
-  }
-
-  const balance = state.balance[event.instrument.quote.toString()];
-  const orderbook = state.orderbook[event.instrument.toString()];
-
-  let position = balance.position[event.id];
-
-  if (event.size == 0) {
-    if (position) {
-      position.averageExecutionRate = event.instrument.quote.fixed(event.rate);
-      position.size = event.instrument.base.fixed(event.size);
-      position.leverage = event.leverage;
-
-      delete balance.position[event.id];
-
-      if (orderbook) {
-        const rate = position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
-
-        position.calculatePnL(rate);
-      }
-
-      changes.commit(position);
-      changes.commit(balance);
-    }
-  }
-
-  if (!position) {
-    position = new Position(event.id, event.instrument);
-
-    balance.position[event.id] = position;
-  }
-
-  position.averageExecutionRate = event.instrument.quote.fixed(event.rate);
-  position.size = event.instrument.base.fixed(event.size);
-  position.leverage = event.leverage;
-  position.mode = event.mode;
-
-  if (orderbook) {
-    const rate = position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
-
-    position.calculatePnL(rate);
-  }
-
-  changes.commit(position);
-  changes.commit(balance);
-}

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

@@ -1,60 +0,0 @@
-import { Asset, Instrument } from '../../domain';
-import { now } from '../../shared';
-import { Store } from '..';
-import { TradePatchEvent } from '.';
-
-const instrument = new Instrument(
-  new Asset('btc', 'binance', 8),
-  new Asset('usdt', 'binance', 2),
-  'binance:btc-usdt'
-);
-
-describe('trade patch event tests', () => {
-  test('should create a new trade object and patch a store', () => {
-    const timestamp = now();
-    const store = new Store();
-
-    store.snapshot.universe.instrument[instrument.toString()] = instrument;
-    store.snapshot.subscription.instrument[instrument.toString()] = instrument;
-
-    store.dispatch(new TradePatchEvent(instrument, 1000, 0.1, timestamp));
-
-    const trade = store.snapshot.trade[instrument.toString()];
-
-    expect(trade.timestamp).toEqual(timestamp);
-    expect(trade.instrument.toString()).toEqual(trade.instrument.toString());
-    expect(trade.rate).toEqual(1000);
-    expect(trade.quantity).toEqual(0.1);
-    expect(store.snapshot.timestamp).toEqual(timestamp);
-  });
-
-  test('should use the existing instance of trade when patching a store', () => {
-    const store = new Store();
-
-    store.snapshot.universe.instrument[instrument.toString()] = instrument;
-    store.snapshot.subscription.instrument[instrument.toString()] = instrument;
-
-    store.dispatch(new TradePatchEvent(instrument, 1000, 0.1, now()));
-
-    const timestamp = now();
-    const trade = store.snapshot.trade[instrument.toString()];
-
-    store.dispatch(new TradePatchEvent(instrument, 2000, 0.2, now()));
-
-    expect(trade.timestamp).toEqual(timestamp);
-    expect(trade.instrument.toString()).toEqual(instrument.toString());
-    expect(trade.rate).toEqual(2000);
-    expect(trade.quantity).toEqual(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, 1000, 0.1, now()));
-    };
-
-    expect(fn).toThrow(Error);
-  });
-});

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

@@ -1,52 +0,0 @@
-import { Trade } from '../../domain';
-import { InstrumentSelector } from '../../domain/instrument';
-import { timestamp } from '../../shared';
-import { event } from '../../shared/topic';
-import { State, StateChangeTracker } from '../store.state';
-import { StoreEvent } from './store.event';
-
-/**
- * Patches market trade execution.
- */
-@event
-export class TradePatchEvent implements StoreEvent {
-  type = 'trade-patch';
-
-  constructor(
-    readonly instrument: InstrumentSelector,
-    readonly rate: number,
-    readonly quantity: number,
-    readonly timestamp: timestamp
-  ) {}
-}
-
-/**
- * Patches a store with specific event @see TradePatchEvent
- * If there is no specific @see Trade in store, it will create a new one.
- */
-export function TradePatchEventHandler(
-  event: TradePatchEvent,
-  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 trade = state.trade[instrumentKey];
-  if (!trade) {
-    trade = new Trade(state.universe.instrument[instrumentKey]);
-
-    state.trade[instrumentKey] = trade;
-  }
-
-  state.timestamp = event.timestamp;
-
-  trade.timestamp = event.timestamp;
-  trade.rate = trade.instrument.quote.fixed(event.rate);
-  trade.quantity = trade.instrument.base.fixed(event.quantity);
-
-  changes.commit(trade);
-}

package/src/store/event/store.event.ts

@@ -1,6 +0,0 @@
-import { timestamp } from '../../shared';
-
-export interface StoreEvent {
-  type: string;
-  timestamp: timestamp;
-}

package/src/store/store.state.ts

@@ -1,43 +0,0 @@
-import {
-  Asset,
-  AssetSelector,
-  Balance,
-  Component,
-  Instrument,
-  InstrumentSelector,
-  Order,
-  Orderbook,
-  Trade
-} from '../domain';
-import { timestamp } from '../shared';
-
-export interface StateChangeTracker {
-  commit(component: Component);
-  commitPendingChanges();
-}
-
-export class State {
-  timestamp: timestamp;
-
-  // available trading assets and instruments
-  universe: {
-    asset: Record<string, Asset>;
-    instrument: Record<string, Instrument>;
-  } = {
-    asset: {},
-    instrument: {}
-  };
-
-  subscription: {
-    asset: Record<string, AssetSelector>;
-    instrument: Record<string, InstrumentSelector>;
-  } = {
-    asset: {},
-    instrument: {}
-  };
-
-  trade: Record<string, Trade> = {};
-  orderbook: Record<string, Orderbook> = {};
-  balance: Record<string, Balance> = {};
-  order: Record<string, Order> = {};
-}

package/src/tests/backtester-adapter.spec.ts

@@ -1,88 +0,0 @@
-import { Adapter, AdapterContext } from '../adapter/adapter';
-import { BacktesterAdapter } from '../adapter/backtester/backtester-adapter';
-import { BacktesterStreamer } from '../adapter/backtester/backtester-streamer';
-import { PaperSpotSimulator } from '../adapter/paper';
-import { PaperAdapter } from '../adapter/paper/paper-adapter';
-import { PaperSimulator } from '../adapter/paper/simulator/paper-simulator';
-import { Asset, Commission, instrumentOf } from '../domain';
-import { Cache, Feed, InMemoryStorage } from '../storage';
-import { InstrumentPatchEvent, Store, TradePatchEvent } from '../store';
-
-const base = new Asset('btc', 'binance', 8);
-const quote = new Asset('usdt', 'binance', 4);
-
-class DefaultAdapter extends Adapter {
-  name = 'default';
-
-  timestamp() {
-    return 123;
-  }
-
-  createPaperSimulator(adapter: PaperAdapter): PaperSimulator {
-    return new PaperSpotSimulator(adapter);
-  }
-
-  async awake(context: AdapterContext): Promise<void> {
-    await super.awake(context);
-
-    context.dispatch(
-      new InstrumentPatchEvent(
-        context.timestamp,
-        base,
-        quote,
-        new Commission(0.1, 0.1),
-        'btc-usdt'
-      )
-    );
-  }
-}
-
-const instrument = instrumentOf('binance:btc-usdt');
-const adapter = new DefaultAdapter();
-const store = new Store();
-const feed = new Feed(new InMemoryStorage());
-const cache = new Cache(new InMemoryStorage());
-
-describe('backtester adapter tests', () => {
-  test('should return proper adapter name and timestamp', () => {
-    const sut = new BacktesterAdapter(
-      adapter,
-      new BacktesterStreamer(store, feed, {
-        from: 1,
-        to: 100
-      })
-    );
-
-    expect(sut.name).toEqual('default');
-    expect(sut.timestamp()).toEqual(1);
-  });
-
-  test('should stream data from input array', done => {
-    const streamer = new BacktesterStreamer(
-      store,
-      feed,
-      {
-        from: 0,
-        to: 100
-      },
-      {
-        onBacktestCompleted: () => {
-          expect(store.snapshot.timestamp).toEqual(1);
-          expect(store.snapshot.trade[instrument.toString()].rate).toEqual(100);
-          expect(store.snapshot.trade[instrument.toString()].quantity).toEqual(10);
-
-          done();
-        }
-      }
-    );
-
-    feed.save(instrument, [new TradePatchEvent(instrument, 100, 10, 1)]);
-
-    const sut = new BacktesterAdapter(adapter, streamer);
-
-    sut.awake(new AdapterContext(sut, store, cache));
-    sut.subscribe([instrument]);
-
-    expect(sut.name).toEqual('default');
-  });
-});

package/src/tests/session.spec.ts

@@ -1,121 +0,0 @@
-/*
-
-describe('session paper tests', () => {
-  const descriptor: SessionDescriptor = {
-    awake: () => Promise.resolve(),
-    dispose: () => Promise.resolve(),
-    measurement: null,
-    adapter: () => [new ExchangeBinanceAdapter()],
-    options: () => ({
-      from: 0,
-      to: 0,
-      feed: null,
-      balance: {
-        ['binance:btc']: 1.23
-      }
-    })
-  };
-
-  test('should pipe balance reply on subscription', async done => {
-    const session = SessionFactory.paper(descriptor);
-    await session.initialize();
-
-    session.balance(assetOf('binance:btc')).subscribe({
-      next: it => {
-        expect(it.free).toEqual(1.23);
-        done();
-      }
-    });
-  });
-
-  test('should pipe history', async done => {
-    const session = SessionFactory.paper(descriptor);
-    await session.initialize();
-
-    session
-      .history(instrumentOf('binance:btc-usdt'), Timeframe.D1, 5)
-      .pipe(finalize(() => done()))
-      .subscribe();
-  });
-
-  test('should pipe orders', async done => {
-    const session = SessionFactory.paper(descriptor);
-    await session.initialize();
-
-    session
-      .orders(instrumentOf('binance:btc-usdt'))
-      .pipe(
-        tap(pending => {
-          expect(pending.length).toBe(0);
-          done();
-        })
-      )
-      .subscribe();
-  });
-});
-
-describe('session backtest integration tests', () => {
-  test('should pipe trade execustions', async done => {
-    const instrument = instrumentOf('binance:btc-usdt');
-    const feed = new InMemoryFeed();
-    const session = SessionFactory.backtest([new ExchangeBinanceAdapter()], {
-      feed: feed,
-      from: 0,
-      to: 100,
-      balance: {}
-    });
-
-    await feed.write(instrument, [
-      new TradePatchEvent(instrument, 1, 1, 1),
-      new TradePatchEvent(instrument, 2, 1, 2),
-      new TradePatchEvent(instrument, 3, 1, 3)
-    ]);
-
-    session
-      .trade(instrument)
-      .pipe(
-        take(1),
-        map(it => {
-          expect(it.rate).toEqual(1);
-          done();
-        })
-      )
-      .subscribe();
-
-    await session.initialize();
-  });
-
-  test('should wait for latest history when trade executed', async done => {
-    const instrument = instrumentOf('binance:btc-usdt');
-    const feed = new InMemoryFeed();
-    const timestamp = now();
-    const session = SessionFactory.backtest([new ExchangeBinanceAdapter()], {
-      feed: feed,
-      from: timestamp,
-      to: timestamp + 100,
-      balance: {}
-    });
-
-    await feed.write(instrument, [
-      new TradePatchEvent(instrument, 1, 1, timestamp + 1),
-      new TradePatchEvent(instrument, 2, 1, timestamp + 2),
-      new TradePatchEvent(instrument, 3, 1, timestamp + 3)
-    ]);
-
-    session
-      .trade(instrument)
-      .pipe(
-        take(1),
-        withLatestFrom(session.history(instrument, Timeframe.D1, 3)),
-        map(([trade, history]) => {
-          expect(history.close).toBeGreaterThan(0);
-          expect(trade.rate).toEqual(1);
-          done();
-        })
-      )
-      .subscribe();
-
-    await session.initialize();
-  });
-});
-*/