@quantform/core 0.6.6 → 0.7.0-beta.4

package/src/adapter/paper/engine/paper-engine.spec.ts

@@ -1,116 +0,0 @@
-import {
-  Asset,
-  Commission,
-  commissionPercentOf,
-  Instrument,
-  Order
-} from '../../../domain';
-import { d, now } from '../../../shared';
-import {
-  BalancePatchEvent,
-  InstrumentPatchEvent,
-  InstrumentSubscriptionEvent,
-  OrderbookPatchEvent,
-  Store
-} from '../../../store';
-import { PaperEngine } from './paper-engine';
-
-describe('PaperEngine', () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('btc', 'binance', 8),
-    new Asset('usdt', 'binance', 2),
-    'binance:btc-usdt',
-    Commission.Zero
-  );
-
-  const commission = commissionPercentOf({
-    maker: d(0.1),
-    taker: d(0.1)
-  });
-
-  test('should open a new buy market order', () => {
-    const store = new Store();
-    const engine = new PaperEngine(store);
-    const order = new Order(0, '1', instrument, d(1.0), 0);
-
-    store.dispatch(
-      new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
-      new BalancePatchEvent(instrument.base, d(1), d.Zero, now()),
-      new BalancePatchEvent(instrument.quote, d(1000), d.Zero, now())
-    );
-
-    engine.open(order);
-
-    const pendingOrder = store.snapshot.order.get(instrument.id)?.get(order.id) ?? fail();
-    const balance = store.snapshot.balance.get(instrument.quote.id) ?? fail();
-
-    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(pendingOrder).toEqual(order);
-    expect(balance.free).toEqual(d.Zero);
-    expect(balance.locked).toEqual(d(1000));
-  });
-
-  test('should open a new sell market order', () => {
-    const store = new Store();
-    const engine = new PaperEngine(store);
-    const order = new Order(0, '1', instrument, d(-0.6), 0);
-
-    store.dispatch(
-      new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
-      new BalancePatchEvent(instrument.base, d(1), d.Zero, now()),
-      new BalancePatchEvent(instrument.quote, d(1000), d.Zero, now())
-    );
-
-    engine.open(order);
-
-    const pendingOrder = store.snapshot.order.get(instrument.id)?.get(order.id) ?? fail();
-    const balance = store.snapshot.balance.get(instrument.base.id) ?? fail();
-
-    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(pendingOrder).toEqual(order);
-    expect(balance.free).toEqual(d(0.4));
-    expect(balance.locked).toEqual(d(0.6));
-  });
-
-  test('should open and fill a new sell limit order', () => {
-    const store = new Store();
-    const engine = new PaperEngine(store);
-    const order = new Order(0, '1', instrument, d(-0.6), 0, d(100));
-
-    store.dispatch(
-      new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
-      new BalancePatchEvent(instrument.base, d(1), d.Zero, now()),
-      new BalancePatchEvent(instrument.quote, d(1000), d.Zero, now()),
-      new InstrumentSubscriptionEvent(now(), instrument, true)
-    );
-
-    engine.open(order);
-
-    const pendingOrder = store.snapshot.order.get(instrument.id)?.get(order.id) ?? fail();
-    const baseBalance = store.snapshot.balance.get(instrument.base.id) ?? fail();
-
-    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(pendingOrder.state).toEqual('PENDING');
-    expect(baseBalance.free).toEqual(d(0.4));
-    expect(baseBalance.locked).toEqual(d(0.6));
-
-    store.dispatch(
-      new OrderbookPatchEvent(
-        instrument,
-        { rate: d(102), quantity: d(1), next: undefined },
-        { rate: d(101), quantity: d(1), next: undefined },
-        now()
-      )
-    );
-
-    const quoteBalance = store.snapshot.balance.get(instrument.quote.id) ?? fail();
-
-    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(pendingOrder.state).toEqual('FILLED');
-    expect(baseBalance.free).toEqual(d(0.4));
-    expect(baseBalance.locked).toEqual(d.Zero);
-    expect(quoteBalance.free).toEqual(d(1060.53));
-    expect(quoteBalance.locked).toEqual(d.Zero);
-  });
-});

package/src/adapter/paper/engine/paper-engine.ts

@@ -1,151 +0,0 @@
-import { tap } from 'rxjs';
-
-import { Order, Orderbook, Trade } from '../../../domain';
-import { d, decimal } from '../../../shared';
-import {
-  BalanceLockOrderEvent,
-  BalanceTransactEvent,
-  BalanceUnlockOrderEvent,
-  OrderCanceledEvent,
-  OrderCancelingEvent,
-  OrderFilledEvent,
-  OrderNewEvent,
-  OrderPendingEvent,
-  OrderRejectedEvent,
-  Store
-} from '../../../store';
-import { instrumentNotSupportedError } from '../../../store/error';
-
-export class PaperEngine {
-  constructor(private readonly store: Store) {
-    store.changes$
-      .pipe(
-        tap(it => {
-          if (it instanceof Orderbook) {
-            this.onOrderbook(it);
-          } else if (it instanceof Trade) {
-            this.onTrade(it);
-          }
-        })
-      )
-      .subscribe();
-  }
-
-  public open(order: Order) {
-    const { timestamp } = this.store.snapshot;
-
-    try {
-      this.store.dispatch(
-        new OrderNewEvent(order, timestamp),
-        new BalanceLockOrderEvent(order.id, order.instrument, timestamp)
-      );
-
-      this.store.dispatch(new OrderPendingEvent(order.id, order.instrument, timestamp));
-    } catch (error) {
-      this.store.dispatch(
-        new BalanceUnlockOrderEvent(order.id, order.instrument, timestamp),
-        new OrderRejectedEvent(order.id, order.instrument, timestamp)
-      );
-    }
-  }
-
-  public cancel(order: Order) {
-    const { timestamp } = this.store.snapshot;
-
-    this.store.dispatch(new OrderCancelingEvent(order.id, order.instrument, timestamp));
-
-    this.store.dispatch(
-      new BalanceUnlockOrderEvent(order.id, order.instrument, timestamp),
-      new OrderCanceledEvent(order.id, order.instrument, timestamp)
-    );
-  }
-
-  private onOrderbook(orderbook: Orderbook) {
-    const orders = this.store.snapshot.order.get(orderbook.instrument.id);
-    if (!orders) {
-      return;
-    }
-
-    orders.asReadonlyArray().forEach(it => {
-      if (it.state != 'PENDING') {
-        return;
-      }
-
-      if (it.rate) {
-        if (it.quantity.greaterThan(0) && it.rate.greaterThan(orderbook.asks.rate)) {
-          this.completeOrder(it, orderbook.asks.rate);
-        } else if (it.quantity.lessThan(0) && it.rate.lessThan(orderbook.bids.rate)) {
-          this.completeOrder(it, orderbook.bids.rate);
-        }
-      } else {
-        if (it.quantity.greaterThan(0)) {
-          this.completeOrder(it, orderbook.asks.rate);
-        } else if (it.quantity.lessThan(0)) {
-          this.completeOrder(it, orderbook.bids.rate);
-        }
-      }
-    });
-  }
-
-  private onTrade(trade: Trade) {
-    const orders = this.store.snapshot.order.get(trade.instrument.id);
-    if (!orders) {
-      return;
-    }
-
-    orders.asReadonlyArray().forEach(it => {
-      if (it.state != 'PENDING') {
-        return;
-      }
-
-      if (it.rate) {
-        if (it.quantity.greaterThan(0) && it.rate.greaterThan(trade.rate)) {
-          this.completeOrder(it, trade.rate);
-        } else if (it.quantity.lessThan(0) && it.rate.lessThan(trade.rate)) {
-          this.completeOrder(it, trade.rate);
-        }
-      } else {
-        this.completeOrder(it, trade.rate);
-      }
-    });
-  }
-
-  private completeOrder(order: Order, averageExecutionRate: decimal) {
-    const { timestamp } = this.store.snapshot;
-
-    const instrument = this.store.snapshot.universe.instrument.get(order.instrument.id);
-    if (!instrument) {
-      throw instrumentNotSupportedError(order.instrument);
-    }
-
-    const transacted = {
-      base: d.Zero,
-      quote: d.Zero
-    };
-
-    const qty = order.quantity.abs();
-
-    if (order.quantity.greaterThan(0)) {
-      transacted.base = transacted.base.plus(
-        instrument.base.floor(instrument.commission.applyMakerFee(qty))
-      );
-      transacted.quote = transacted.quote.minus(
-        instrument.quote.floor(averageExecutionRate.mul(qty))
-      );
-    } else if (order.quantity.lessThan(0)) {
-      transacted.base = transacted.base.minus(instrument.base.floor(qty));
-      transacted.quote = transacted.quote.plus(
-        instrument.quote.floor(
-          instrument.commission.applyMakerFee(averageExecutionRate.mul(qty))
-        )
-      );
-    }
-
-    this.store.dispatch(
-      new BalanceUnlockOrderEvent(order.id, order.instrument, timestamp),
-      new OrderFilledEvent(order.id, order.instrument, averageExecutionRate, timestamp),
-      new BalanceTransactEvent(instrument.base, transacted.base, timestamp),
-      new BalanceTransactEvent(instrument.quote, transacted.quote, timestamp)
-    );
-  }
-}

package/src/adapter/paper/index.ts

@@ -1,2 +0,0 @@
-export * from './paper-adapter';
-export * from './engine/paper-engine';

package/src/adapter/paper/paper-adapter.ts

@@ -1,111 +0,0 @@
-import { assetOf, InstrumentSelector, Ohlc, Order } from '../../domain';
-import { d, decimal, timestamp } from '../../shared';
-import { BalancePatchEvent, Store } from '../../store';
-import { Adapter } from '..';
-import { AdapterFactory, FeedAsyncCallback } from '../adapter';
-import { noPaperEngineProvidedError } from '../error';
-import { PaperEngine } from './engine/paper-engine';
-
-export interface PaperOptions {
-  balance: { [key: string]: decimal };
-}
-
-export function createPaperAdapterFactory(
-  decoratedAdapterFactory: AdapterFactory,
-  options: PaperOptions
-): AdapterFactory {
-  return (timeProvider, store, cache) =>
-    new PaperAdapter(decoratedAdapterFactory(timeProvider, store, cache), store, options);
-}
-
-export class PaperAdapter extends Adapter {
-  readonly name = this.decoratedAdapter.name;
-  private engine?: PaperEngine;
-
-  constructor(
-    readonly decoratedAdapter: Adapter,
-    readonly store: Store,
-    readonly options: PaperOptions
-  ) {
-    super({
-      timestamp: () => this.decoratedAdapter.timestamp()
-    });
-  }
-
-  async awake(): Promise<void> {
-    this.engine = this.createPaperEngine(this);
-
-    await this.decoratedAdapter.awake();
-  }
-
-  dispose(): Promise<void> {
-    return this.decoratedAdapter.dispose();
-  }
-
-  subscribe(instruments: InstrumentSelector[]): Promise<void> {
-    return this.decoratedAdapter.subscribe(instruments);
-  }
-
-  async account(): Promise<void> {
-    let subscribed = Object.values(this.store.snapshot.subscription.asset).filter(
-      it => it.adapterName == this.name
-    );
-
-    for (const balance in this.options.balance) {
-      const asset = assetOf(balance);
-
-      if (asset.adapterName != this.name) {
-        continue;
-      }
-
-      const free = this.options.balance[balance];
-
-      subscribed = subscribed.filter(it => it.id != asset.id);
-
-      this.store.dispatch(new BalancePatchEvent(asset, free, d.Zero, this.timestamp()));
-    }
-
-    for (const missingAsset of subscribed) {
-      this.store.dispatch(
-        new BalancePatchEvent(missingAsset, d.Zero, d.Zero, this.timestamp())
-      );
-    }
-  }
-
-  async open(order: Order): Promise<void> {
-    if (!this.engine) {
-      throw noPaperEngineProvidedError();
-    }
-
-    this.engine.open(order);
-  }
-
-  async cancel(order: Order): Promise<void> {
-    if (!this.engine) {
-      throw noPaperEngineProvidedError();
-    }
-
-    this.engine.cancel(order);
-  }
-
-  history(
-    instrument: InstrumentSelector,
-    timeframe: number,
-    length: number
-  ): Promise<Ohlc[]> {
-    return this.decoratedAdapter.history(instrument, timeframe, length);
-  }
-
-  feed(
-    instrument: InstrumentSelector,
-    from: timestamp,
-    to: timestamp,
-    callback: FeedAsyncCallback
-  ): Promise<void> {
-    return this.decoratedAdapter.feed(instrument, from, to, callback);
-  }
-
-  createPaperEngine(adapter: PaperAdapter): PaperEngine {
-    return this.decoratedAdapter.createPaperEngine(adapter);
-  }
-}

package/src/cli/error.ts

@@ -1,5 +0,0 @@
-export function missingDescriptorParameterError(parameterName: string) {
-  return new Error(
-    `please set a "${parameterName}" date in session descriptor or provide the date as parameter.`
-  );
-}

package/src/cli/test.ts

@@ -1,40 +0,0 @@
-import { join } from 'path';
-
-import { SessionBuilder } from '../domain/session-builder';
-import { Logger, now } from '../shared';
-import { spawn } from '..';
-import build from './build';
-import { buildDirectory } from './internal/workspace';
-
-export default async function (name: string, options: any) {
-  if (await build()) {
-    return;
-  }
-
-  await import(join(buildDirectory(), 'index'));
-
-  const builder = new SessionBuilder().useSessionId(
-    options.id ? Number(options.id) : now()
-  );
-
-  const rules = await spawn(name, builder);
-
-  const startTime = performance.now();
-
-  const [session, backtester] = builder.backtest({
-    onBacktestStarted: () => Logger.info('backtest', `new session ${session.id} started`),
-    onBacktestCompleted: async () => {
-      await session.dispose();
-
-      const seconds = ((performance.now() - startTime) / 1000).toFixed(3);
-
-      Logger.info('backtest', `session ${session.id} completed in ${seconds}s`);
-    }
-  });
-
-  await session.awake();
-
-  rules(session).subscribe();
-
-  backtester.tryContinue();
-}

package/src/domain/balance-operator.spec.ts

@@ -1,26 +0,0 @@
-import { Subject } from 'rxjs';
-
-import { State } from '../store';
-import { Asset } from './asset';
-import { Balance } from './balance';
-import { balance } from './balance-operator';
-import { Component } from './component';
-
-describe('balance', () => {
-  const timestamp = 0;
-  const asset = new Asset('abc', 'xyz', 4);
-  const state = new State();
-
-  beforeEach(() => {
-    state.balance.upsert(new Balance(timestamp, asset));
-  });
-
-  test('should pipe a balance snapshot when subscribed', done => {
-    new Subject<Component>().pipe(balance(asset, state)).subscribe({
-      next: it => {
-        expect(it.asset).toEqual(asset);
-        done();
-      }
-    });
-  });
-});

package/src/domain/balance-operator.ts

@@ -1,15 +0,0 @@
-import { filter, map, Observable, startWith } from 'rxjs';
-
-import { State } from '../store';
-import { AssetSelector } from './asset';
-import { Balance } from './balance';
-import { Component } from './component';
-
-export function balance(selector: AssetSelector, state: State) {
-  return (source$: Observable<Component>) =>
-    source$.pipe(
-      startWith(state.balance.get(selector.id)),
-      filter(it => it instanceof Balance && (!selector || it.asset.id == selector.id)),
-      map(it => it as Balance)
-    );
-}

package/src/domain/balance.spec.ts

@@ -1,116 +0,0 @@
-import { d } from '../shared';
-import { Asset } from './asset';
-import { Balance } from './balance';
-import { Commission } from './commission';
-import { Instrument } from './instrument';
-import { Position } from './position';
-
-describe('Balance', () => {
-  const asset = new Asset('abc', 'xyz', 4);
-  const instrument = new Instrument(
-    0,
-    new Asset('abc', 'xyz', 4),
-    new Asset('def', 'xyz', 4),
-    'abc-def',
-    Commission.Zero
-  );
-
-  test('should construct empty balance', () => {
-    const sut = new Balance(0, asset);
-
-    expect(sut.asset.id).toEqual('xyz:abc');
-    expect(sut.free).toEqual(d.Zero);
-    expect(sut.locked).toEqual(d.Zero);
-    expect(Object.keys(sut.position).length).toEqual(0);
-  });
-
-  test('should construct balance', () => {
-    const sut = new Balance(1, asset);
-
-    sut.set(d(100), d(50));
-
-    expect(sut.asset.id).toEqual('xyz:abc');
-    expect(sut.free).toEqual(d(100));
-    expect(sut.locked).toEqual(d(50));
-    expect(sut.total).toEqual(d(150));
-    expect(Object.keys(sut.position).length).toEqual(0);
-  });
-
-  test('should account positive amount', () => {
-    const sut = new Balance(0, asset);
-
-    sut.set(d(100), d.Zero);
-    sut.account(d(10));
-
-    expect(sut.free).toEqual(d(110));
-    expect(sut.locked).toEqual(d.Zero);
-    expect(sut.total).toEqual(d(110));
-  });
-
-  test('should account negative amount', () => {
-    const sut = new Balance(0, asset);
-
-    sut.set(d(100), d.Zero);
-    sut.account(d(-10));
-
-    expect(sut.free).toEqual(d(90));
-    expect(sut.locked).toEqual(d.Zero);
-    expect(sut.total).toEqual(d(90));
-  });
-
-  test('should throw for insufficient balance account amount', () => {
-    const sut = new Balance(0, asset);
-
-    sut.set(d(100), d.Zero);
-    const fn = () => sut.account(d(-120));
-
-    expect(fn).toThrowError();
-  });
-
-  test('should lock specific amount of available balance', () => {
-    const sut = new Balance(0, asset);
-
-    sut.set(d(100), d.Zero);
-    sut.lock('key', d(10));
-
-    expect(sut.free).toEqual(d(90));
-    expect(sut.locked).toEqual(d(10));
-    expect(sut.total).toEqual(d(100));
-  });
-
-  test('should throw for lock insufficient amount of available balance', () => {
-    const sut = new Balance(0, asset);
-
-    sut.set(d(30), d(50));
-    const fn = () => sut.lock('key', d(100));
-
-    expect(fn).toThrowError();
-  });
-
-  test('should lock and unlock specific amount of available balance', () => {
-    const sut = new Balance(0, asset);
-
-    sut.set(d(100), d.Zero);
-    sut.lock('key', d(40));
-    sut.tryUnlock('key');
-
-    expect(sut.free).toEqual(d(100));
-    expect(sut.locked).toEqual(d.Zero);
-    expect(sut.total).toEqual(d(100));
-  });
-
-  test('should return correct estimated unrealized pnl', () => {
-    const position = new Position(0, '1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
-
-    position.calculateEstimatedUnrealizedPnL(d(2576.44));
-
-    const sut = new Balance(0, asset);
-
-    sut.set(d(100), d.Zero);
-    sut.position['1'] = position;
-
-    expect(sut.getEstimatedUnrealizedPnL()).toEqual(d(0.2652));
-    expect(sut.free).toEqual(d(100).add(d(0.2652)));
-    expect(sut.total).toEqual(d(100).add(d(0.2652)));
-  });
-});