@quantform/core 0.5.14 → 0.5.15

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

@@ -1,108 +0,0 @@
-import { Order } from '../../../domain';
-import { pnl, weightedMean } from '../../../shared';
-import {
-  BalanceTransactEvent,
-  OrderCanceledEvent,
-  OrderCancelingEvent,
-  OrderFilledEvent,
-  OrderNewEvent,
-  OrderPendingEvent,
-  PositionPatchEvent
-} from '../../../store';
-import { PaperAdapter } from '..';
-import { PaperSimulator } from './paper-simulator';
-
-export class PaperMarginSimulator extends PaperSimulator {
-  leverage = 10;
-
-  constructor(adapter: PaperAdapter) {
-    super(adapter);
-  }
-
-  onOrderOpened(order: Order) {
-    const timestamp = this.adapter.timestamp();
-
-    this.adapter.store.dispatch(new OrderNewEvent(order, timestamp));
-    this.adapter.store.dispatch(new OrderPendingEvent(order.id, timestamp));
-  }
-
-  onOrderCompleted(order: Order, averageExecutionRate: number, timestamp: number) {
-    const instrument =
-      this.adapter.store.snapshot.universe.instrument[order.instrument.toString()];
-
-    let transact = instrument.quote.floor(
-      -instrument.commission.calculateMakerFee(averageExecutionRate * order.quantity)
-    );
-
-    const id = instrument.toString();
-    const position =
-      this.adapter.store.snapshot.balance[instrument.quote.toString()].position[id];
-
-    let rate = position?.averageExecutionRate ?? 0;
-    let size = position?.size ?? 0;
-    let quantity = order.quantity;
-
-    switch (order.side) {
-      case 'BUY':
-        if (size < 0) {
-          const comsumeQuantity = Math.min(Math.abs(size), quantity);
-
-          transact += pnl(averageExecutionRate, rate, comsumeQuantity);
-
-          size += comsumeQuantity;
-          quantity -= comsumeQuantity;
-        }
-
-        if (!size) {
-          rate = averageExecutionRate;
-          size = quantity;
-        } else {
-          rate = weightedMean([rate, averageExecutionRate], [size, quantity]);
-          size += quantity;
-        }
-
-        break;
-
-      case 'SELL':
-        if (size > 0) {
-          const comsumeQuantity = Math.min(size, quantity);
-
-          transact += pnl(rate, averageExecutionRate, comsumeQuantity);
-
-          size -= comsumeQuantity;
-          quantity -= comsumeQuantity;
-        }
-
-        if (!size) {
-          rate = averageExecutionRate;
-          size = -quantity;
-        } else {
-          rate = weightedMean([rate, averageExecutionRate], [size, -quantity]);
-          size -= quantity;
-        }
-
-        break;
-    }
-
-    this.adapter.store.dispatch(
-      new OrderFilledEvent(order.id, averageExecutionRate, timestamp),
-      new BalanceTransactEvent(instrument.quote, transact, timestamp),
-      new PositionPatchEvent(
-        id,
-        instrument,
-        rate,
-        size,
-        this.leverage,
-        'CROSS',
-        timestamp
-      )
-    );
-  }
-
-  onOrderCanceled(order: Order) {
-    const timestamp = this.adapter.timestamp();
-
-    this.adapter.store.dispatch(new OrderCancelingEvent(order.id, timestamp));
-    this.adapter.store.dispatch(new OrderCanceledEvent(order.id, timestamp));
-  }
-}

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

@@ -1,121 +0,0 @@
-import { tap } from 'rxjs';
-import { Set } from 'typescript-collections';
-
-import { Component, InstrumentSelector, Order, Orderbook, Trade } from '../../../domain';
-import { PaperAdapter } from '..';
-
-export abstract class PaperSimulator {
-  private readonly pending: Record<string, Set<Order>> = {};
-
-  constructor(readonly adapter: PaperAdapter) {
-    this.adapter.store.changes$.pipe(tap(it => this.intercept(it))).subscribe();
-  }
-
-  protected abstract onOrderOpened(order: Order);
-
-  protected abstract onOrderCompleted(
-    order: Order,
-    averageExecutionRate: number,
-    timestamp: number
-  );
-
-  protected abstract onOrderCanceled(order: Order);
-
-  private intercept(component: Component) {
-    if (component instanceof Orderbook) {
-      this.pendingOf(component.instrument).forEach(it =>
-        this.simulateOrderOnOrderbook(it, component)
-      );
-    } else if (component instanceof Trade) {
-      this.pendingOf(component.instrument).forEach(it =>
-        this.simulateOrderOnTrade(it, component)
-      );
-    }
-  }
-
-  private simulateOrderOnOrderbook(order: Order, orderbook: Orderbook) {
-    if (orderbook.timestamp <= order.timestamp) {
-      return;
-    }
-
-    if (order.type == 'MARKET') {
-      if (order.side == 'BUY' && orderbook.bestAskRate) {
-        this.pendingOf(order.instrument).remove(order);
-        this.onOrderCompleted(order, orderbook.bestAskRate, orderbook.timestamp);
-      } else if (order.side == 'SELL' && orderbook.bestBidRate) {
-        this.pendingOf(order.instrument).remove(order);
-        this.onOrderCompleted(order, orderbook.bestBidRate, orderbook.timestamp);
-      }
-
-      return;
-    }
-
-    if (order.type == 'LIMIT') {
-      if (order.side == 'BUY' && order.rate >= orderbook.bestAskRate) {
-        this.pendingOf(order.instrument).remove(order);
-        this.onOrderCompleted(order, orderbook.bestAskRate, orderbook.timestamp);
-      } else if (order.side == 'SELL' && order.rate <= orderbook.bestBidRate) {
-        this.pendingOf(order.instrument).remove(order);
-        this.onOrderCompleted(order, orderbook.bestBidRate, orderbook.timestamp);
-      }
-
-      return;
-    }
-  }
-
-  private simulateOrderOnTrade(order: Order, trade: Trade) {
-    if (trade.timestamp <= order.timestamp) {
-      return;
-    }
-
-    if (order.type == 'MARKET') {
-      this.pendingOf(order.instrument).remove(order);
-      this.onOrderCompleted(order, trade.rate, trade.timestamp);
-
-      return;
-    }
-
-    if (order.type == 'LIMIT') {
-      if (order.side == 'BUY' && order.rate > trade.rate) {
-        this.pendingOf(order.instrument).remove(order);
-        this.onOrderCompleted(order, trade.rate, trade.timestamp);
-      } else if (order.side == 'SELL' && order.rate < trade.rate) {
-        this.pendingOf(order.instrument).remove(order);
-        this.onOrderCompleted(order, trade.rate, trade.timestamp);
-      }
-
-      return;
-    }
-  }
-
-  private pendingOf(instrument: InstrumentSelector) {
-    let pending = this.pending[instrument.toString()];
-    if (!pending) {
-      pending = new Set<Order>();
-
-      this.pending[instrument.toString()] = pending;
-    }
-
-    return pending;
-  }
-
-  open(order: Order) {
-    const pending = this.pendingOf(order.instrument);
-
-    if (!pending.add(order)) {
-      throw new Error('Invalid order');
-    }
-
-    this.onOrderOpened(order);
-  }
-
-  cancel(order: Order) {
-    const pending = this.pendingOf(order.instrument);
-
-    if (!pending.remove(order)) {
-      throw new Error('Invalid order');
-    }
-
-    this.onOrderCanceled(order);
-  }
-}

package/src/adapter/paper/simulator/paper-spot-simulator.spec.ts

@@ -1,87 +0,0 @@
-import { PaperAdapter } from '../paper-adapter';
-import {
-  Asset,
-  assetOf,
-  Commission,
-  commissionPercentOf,
-  instrumentOf,
-  Order
-} from './../../../domain';
-import {
-  BalancePatchEvent,
-  InstrumentPatchEvent,
-  InstrumentSubscriptionEvent,
-  Store,
-  TradePatchEvent
-} from './../../../store';
-import { Adapter, AdapterContext } from './../../adapter';
-import { PaperSimulator } from './paper-simulator';
-import { PaperSpotSimulator } from './paper-spot-simulator';
-
-class DefaultAdapter extends Adapter {
-  name = 'default';
-
-  timestamp() {
-    return 0;
-  }
-
-  async awake(context: AdapterContext): Promise<void> {
-    await super.awake(context);
-
-    context.dispatch(
-      new InstrumentPatchEvent(
-        context.timestamp,
-        new Asset('a', this.name, 8),
-        new Asset('b', this.name, 4),
-        new Commission(0.1, 0.1),
-        'a-b'
-      )
-    );
-  }
-
-  createPaperSimulator(adapter: PaperAdapter): PaperSimulator {
-    return new PaperSpotSimulator(adapter);
-  }
-}
-
-describe('paper spot simulator tests', () => {
-  const options = {
-    balance: {
-      ['default:a']: 1000,
-      ['default:b']: 200
-    }
-  };
-
-  test('should open an market order', async () => {
-    const store = new Store();
-    const adapter = new DefaultAdapter();
-    const order = Order.buyMarket(instrumentOf('default:a-b'), 1);
-
-    store.dispatch(
-      new InstrumentPatchEvent(
-        0,
-        new Asset('a', 'default', 8),
-        new Asset('b', 'default', 4),
-        commissionPercentOf(0.1, 0.1),
-        'a-b'
-      ),
-      new BalancePatchEvent(assetOf('default:a'), 1000, 0, 1)
-    );
-    store.dispatch(new BalancePatchEvent(assetOf('default:b'), 1000, 0, 1));
-    store.dispatch(new InstrumentSubscriptionEvent(1, instrumentOf('default:a-b'), true));
-
-    const sut = new PaperSpotSimulator(new PaperAdapter(adapter, store, options));
-
-    await sut.open(order);
-
-    expect(store.snapshot.order[order.id].state).toBe('PENDING');
-
-    store.dispatch(new TradePatchEvent(instrumentOf('default:a-b'), 5, 1, 2));
-
-    expect(store.snapshot.order[order.id].quantity).toBe(1);
-    expect(store.snapshot.order[order.id].averageExecutionRate).toBe(5);
-    expect(store.snapshot.order[order.id].state).toBe('FILLED');
-    expect(store.snapshot.balance['default:b'].free).toBe(995);
-    expect(store.snapshot.balance['default:a'].free).toBe(1000.999);
-  });
-});

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

@@ -1,134 +0,0 @@
-import { Order } from '../../../domain';
-import { timestamp } from '../../../shared';
-import {
-  BalanceFreezEvent,
-  BalanceTransactEvent,
-  BalanceUnfreezEvent,
-  OrderCanceledEvent,
-  OrderCancelingEvent,
-  OrderFilledEvent,
-  OrderNewEvent,
-  OrderPendingEvent
-} from '../../../store';
-import { PaperAdapter } from '..';
-import { PaperSimulator } from './paper-simulator';
-
-export class PaperSpotSimulator extends PaperSimulator {
-  constructor(readonly adapter: PaperAdapter) {
-    super(adapter);
-  }
-
-  onOrderOpened(order: Order) {
-    const timestamp = this.adapter.timestamp();
-
-    this.adapter.store.dispatch(
-      ...this.caluclateFreezAllocation(order, timestamp),
-      new OrderNewEvent(order, timestamp)
-    );
-    this.adapter.store.dispatch(new OrderPendingEvent(order.id, timestamp));
-  }
-
-  onOrderCompleted(order: Order, averageExecutionRate: number, timestamp: timestamp) {
-    const instrument =
-      this.adapter.store.snapshot.universe.instrument[order.instrument.toString()];
-    const transacted = {
-      base: 0,
-      quote: 0
-    };
-
-    switch (order.side) {
-      case 'BUY':
-        transacted.base += instrument.base.floor(
-          instrument.commission.applyMakerFee(order.quantity)
-        );
-        transacted.quote -= instrument.quote.floor(averageExecutionRate * order.quantity);
-        break;
-
-      case 'SELL':
-        transacted.base -= instrument.base.floor(order.quantity);
-        transacted.quote += instrument.quote.floor(
-          instrument.commission.applyMakerFee(averageExecutionRate * order.quantity)
-        );
-        break;
-    }
-
-    this.adapter.store.dispatch(
-      ...this.caluclateUnfreezAllocation(order, timestamp),
-      new OrderFilledEvent(order.id, averageExecutionRate, timestamp),
-      new BalanceTransactEvent(instrument.base, transacted.base, timestamp),
-      new BalanceTransactEvent(instrument.quote, transacted.quote, timestamp)
-    );
-  }
-
-  onOrderCanceled(order: Order) {
-    const timestamp = this.adapter.timestamp();
-
-    this.adapter.store.dispatch(new OrderCancelingEvent(order.id, timestamp));
-    this.adapter.store.dispatch(
-      ...this.caluclateUnfreezAllocation(order, timestamp),
-      new OrderCanceledEvent(order.id, timestamp)
-    );
-  }
-
-  private caluclateFreezAllocation(
-    order: Order,
-    timestamp: timestamp
-  ): BalanceFreezEvent[] {
-    const snapshot = this.adapter.store.snapshot;
-    const quote = snapshot.balance[order.instrument.quote.toString()];
-
-    switch (order.side) {
-      case 'BUY':
-        switch (order.type) {
-          case 'MARKET':
-            return [new BalanceFreezEvent(order.instrument.quote, quote.free, timestamp)];
-
-          case 'LIMIT':
-            return [
-              new BalanceFreezEvent(
-                order.instrument.quote,
-                quote.asset.ceil(order.rate * order.quantity),
-                timestamp
-              )
-            ];
-        }
-        break;
-
-      case 'SELL':
-        return [new BalanceFreezEvent(order.instrument.base, order.quantity, timestamp)];
-    }
-  }
-
-  private caluclateUnfreezAllocation(
-    order: Order,
-    timestamp: timestamp
-  ): BalanceUnfreezEvent[] {
-    const snapshot = this.adapter.store.snapshot;
-    const quote = snapshot.balance[order.instrument.quote.toString()];
-
-    switch (order.side) {
-      case 'BUY':
-        switch (order.type) {
-          case 'MARKET':
-            return [
-              new BalanceUnfreezEvent(order.instrument.quote, quote.locked, timestamp)
-            ];
-
-          case 'LIMIT':
-            return [
-              new BalanceUnfreezEvent(
-                order.instrument.quote,
-                quote.asset.ceil(order.rate * order.quantity),
-                timestamp
-              )
-            ];
-        }
-        break;
-
-      case 'SELL':
-        return [
-          new BalanceUnfreezEvent(order.instrument.base, order.quantity, timestamp)
-        ];
-    }
-  }
-}

package/src/domain/statement.ts

@@ -1,119 +0,0 @@
-import { combineLatest, finalize, map, take, tap } from 'rxjs';
-
-import { drawdown } from '../indicator';
-import { floor, precision } from '../shared';
-import { InstrumentSelector, Session } from '.';
-
-export function period() {
-  return (session: Session) => {
-    const period = session.useStatement('period');
-
-    return session.store.changes$.pipe(
-      finalize(() => (period.to = new Date(session.timestamp).toISOString())),
-      take(1),
-      tap(it => (period.from = new Date(it.timestamp).toISOString()))
-    );
-  };
-}
-
-export function benchmark(instrument: InstrumentSelector) {
-  return (session: Session) => {
-    const statement = session.useStatement('benchmark');
-
-    let balance: number, entry: number, exit: number;
-    let dd = 0;
-
-    return combineLatest([
-      session.orderbook(instrument),
-      session.balance(instrument.quote),
-      session.orderbook(instrument).pipe(
-        drawdown(it => it.midRate),
-        tap(it => (dd = it))
-      )
-    ]).pipe(
-      map(([orderbook, quote]) => {
-        const price = orderbook.midRate;
-
-        if (!balance) {
-          balance = quote.total;
-        }
-
-        if (!entry) {
-          entry = price;
-        }
-
-        exit = price;
-      }),
-      finalize(() => {
-        const pnl = exit / entry - 1;
-
-        statement.benchmark_entry = entry;
-        statement.benchmark_exit = exit;
-        statement.benchmark_pnl = floor(balance * pnl, precision(entry));
-        statement.benchmark_pnl_pp = floor(pnl * 100, 2);
-        statement.benchmark_drawdown_pp = floor(dd * 100, 2);
-      })
-    );
-  };
-}
-
-export function equity(instrument: InstrumentSelector) {
-  return (session: Session) => {
-    const statement = session.useStatement('benchmark');
-
-    let balance: number, min: number, max: number;
-    let dd = 0;
-    let equity = 0;
-
-    return combineLatest([
-      session.orderbook(instrument),
-      session.balance(instrument.base),
-      session.balance(instrument.quote),
-      session.positions(instrument)
-    ]).pipe(
-      tap(([, , quote]) => {
-        if (!balance) {
-          balance = quote.total;
-        }
-      }),
-      map(([orderbook, base, quote, positions]) =>
-        orderbook.instrument.quote.fixed(
-          quote.total +
-            base.total * orderbook.bestBidRate +
-            positions.reduce(
-              (agg, position) => agg + position.calculatePnL(orderbook.bestBidRate),
-              0
-            )
-        )
-      ),
-      tap(it => {
-        if (!min) {
-          min = it;
-        } else {
-          min = Math.min(min, it);
-        }
-
-        if (!max) {
-          max = it;
-        } else {
-          max = Math.max(max, it);
-        }
-
-        equity = it;
-      }),
-      drawdown(it => it),
-      tap(it => (dd = it)),
-      finalize(() => {
-        const pnl = equity / balance - 1;
-        const scale = precision(equity);
-
-        statement.equity = equity;
-        statement.equity_min = min;
-        statement.equity_max = max;
-        statement.equity_pnl = floor(balance * pnl, scale);
-        statement.equity_pnl_pp = floor(pnl * 100, 2);
-        statement.equity_drawdown_pp = floor(dd * 100, 2);
-      })
-    );
-  };
-}

package/src/shared/policy.spec.ts

@@ -1,25 +0,0 @@
-import { cache } from './policy';
-
-describe('cache policy tests', () => {
-  test('string as key cache', async () => {
-    let counter = 0;
-
-    const request = async () => ++counter;
-
-    expect(await cache('abc', request)).toBe(1);
-    expect(await cache('abc', request)).toBe(1);
-    expect(await cache('abc', () => request())).toBe(1);
-    expect(await cache('abc', () => request())).toBe(1);
-  });
-
-  test('object as key cache', async () => {
-    let counter = 0;
-
-    const request = async () => ++counter;
-
-    expect(await cache({ from: 1, to: 2, content: 'abc' }, request)).toBe(1);
-    expect(await cache({ from: 1, to: 2, content: 'abc' }, request)).toBe(1);
-    expect(await cache({ from: 1, to: 2, content: 'abc' }, () => request())).toBe(1);
-    expect(await cache({ from: 1, to: 2, content: 'abc' }, () => request())).toBe(1);
-  });
-});

package/src/shared/topic.spec.ts

@@ -1,34 +0,0 @@
-import { event, handler, Topic } from './topic';
-
-describe('topic tests', () => {
-  test('string as key cache', () => {
-    interface Event {
-      type: string;
-    }
-
-    interface Context {
-      counter: number;
-    }
-
-    const context = <Context>{
-      counter: 1
-    };
-
-    @event
-    class IncrementEvent implements Event {
-      type = 'increment';
-    }
-
-    class MathematicBaseTopic extends Topic<Event, Context> {}
-    class MathematicTopic extends MathematicBaseTopic {
-      @handler(IncrementEvent)
-      increment(event: IncrementEvent, context: Context) {
-        context.counter++;
-      }
-    }
-
-    new MathematicTopic().dispatch(new IncrementEvent(), context);
-
-    expect(context.counter).toBe(2);
-  });
-});

package/src/shared/topic.ts

@@ -1,43 +0,0 @@
-import 'reflect-metadata';
-
-export class Topic<T extends { type: string } = { type: string }, C = any> {
-  private readonly handler: Record<string, Function> = {};
-
-  constructor() {
-    this.register(this);
-  }
-
-  register(target: any) {
-    for (const key of Reflect.getMetadataKeys(target.constructor.prototype)) {
-      if (!key.startsWith('event:')) {
-        continue;
-      }
-
-      this.handler[key] = Reflect.getMetadata(key, target.constructor.prototype);
-    }
-  }
-
-  dispatch(event: T, context: C): any {
-    const handler = this.handler['event:' + event.type];
-
-    return handler
-      ? handler.call(this, event, context)
-      : this.onUnknownEvent(event, context);
-  }
-
-  onUnknownEvent(event: T, context: C) {
-    throw new Error(`No handler for event ${event.type}`);
-  }
-}
-
-export function handler(event: any) {
-  return function (target: any, key: string) {
-    const type = Reflect.getMetadata('event:type', event.prototype);
-
-    Reflect.defineMetadata('event:' + type, target[key], target);
-  };
-}
-
-export const event = (target: any) => {
-  Reflect.defineMetadata('event:type', new target().type, target.prototype);
-};

package/src/store/event/index.ts

@@ -1,8 +0,0 @@
-export * from './store-balance.event';
-export * from './store-candle.event';
-export * from './store-instrument.event';
-export * from './store-order.event';
-export * from './store-orderbook.event';
-export * from './store-position.event';
-export * from './store-trade.event';
-export * from './store.event';