@quantform/core 0.6.6 → 0.7.0-beta.4

package/src/domain/position-operator.ts

@@ -1,71 +0,0 @@
-import { filter, map, Observable, share, startWith } from 'rxjs';
-
-import { d, decimal, weightedMean } from '../shared';
-import { State } from '../store';
-import { Component } from './component';
-import { invalidInstrumentSelectorError } from './error';
-import { InstrumentSelector } from './instrument';
-import { Position } from './position';
-
-export function position(selector: InstrumentSelector) {
-  return (source: Observable<Component>) =>
-    source.pipe(
-      filter(it => it instanceof Position && it.instrument.id == selector.id),
-      map(it => it as Readonly<Position>)
-    );
-}
-
-export function positions(selector: InstrumentSelector, state: State) {
-  const balance = state.balance.get(selector.quote.id);
-  if (!balance) {
-    throw invalidInstrumentSelectorError(selector.id);
-  }
-
-  const getter = () =>
-    Object.values(balance.position)
-      .filter(it => it.instrument.id == selector.id)
-      .map(it => it as Readonly<Position>);
-
-  return (source: Observable<Component>) =>
-    source.pipe(
-      position(selector),
-      map(() => getter()),
-      startWith(getter())
-    );
-}
-
-export function flatten() {
-  return function (
-    source: Observable<Position[]>
-  ): Observable<{ size: decimal; rate: decimal }> {
-    return source.pipe(
-      map(it => {
-        if (it.length > 1) {
-          return {
-            size: it.reduce(
-              (aggregate, position) => aggregate.add(position.size),
-              d.Zero
-            ),
-            rate: weightedMean(
-              it.map(x => x.averageExecutionRate),
-              it.map(x => x.size)
-            )
-          };
-        }
-
-        if (it.length == 1) {
-          return {
-            size: it[0].size,
-            rate: it[0].averageExecutionRate
-          };
-        }
-
-        return {
-          size: d.Zero,
-          rate: d.Zero
-        };
-      }),
-      share()
-    );
-  };
-}

package/src/domain/position.spec.ts

@@ -1,43 +0,0 @@
-import { d } from '../shared';
-import { Asset } from './asset';
-import { Commission } from './commission';
-import { Instrument } from './instrument';
-import { Position } from './position';
-
-describe('Position', () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('abc', 'xyz', 4),
-    new Asset('def', 'xyz', 4),
-    'abc-def',
-    Commission.Zero
-  );
-
-  test('should construct a position', () => {
-    const sut = new Position(0, '1', instrument, 'CROSS', d(10), d(2), 3);
-
-    expect(sut.id).toEqual('1');
-    expect(sut.mode).toEqual('CROSS');
-    expect(sut.averageExecutionRate).toEqual(d(10));
-    expect(sut.size).toEqual(d(2));
-    expect(sut.leverage).toEqual(3);
-    expect(sut.estimatedUnrealizedPnL).toEqual(undefined);
-    expect(sut.id).toEqual('1');
-  });
-
-  test('should calculate correct margin', () => {
-    const sut = new Position(0, '1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
-
-    expect(sut.margin).toEqual(d(0.5155));
-    expect(sut.estimatedUnrealizedPnL).toEqual(undefined);
-  });
-
-  test('should calculate correct unrealized pnl', () => {
-    const sut = new Position(0, '1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
-
-    const pnl = sut.calculateEstimatedUnrealizedPnL(d(2576.44));
-
-    expect(pnl).toEqual(d(0.2652));
-    expect(sut.estimatedUnrealizedPnL).toEqual(d(0.2652));
-  });
-});

package/src/domain/position.ts

@@ -1,31 +0,0 @@
-import { Instrument } from '../domain';
-import { decimal, pnl } from '../shared';
-import { Component } from './component';
-
-export type PositionMode = 'CROSS' | 'ISOLATED';
-
-export class Position implements Component {
-  estimatedUnrealizedPnL?: decimal;
-
-  get margin(): decimal {
-    return this.instrument.quote.floor(this.size.abs().div(this.leverage));
-  }
-
-  constructor(
-    public timestamp: number,
-    readonly id: string,
-    readonly instrument: Instrument,
-    readonly mode: PositionMode,
-    public averageExecutionRate: decimal,
-    public size: decimal,
-    public leverage: number
-  ) {}
-
-  calculateEstimatedUnrealizedPnL(rate: decimal): decimal {
-    this.estimatedUnrealizedPnL = this.instrument.quote.floor(
-      pnl(this.averageExecutionRate, rate, this.size)
-    );
-
-    return this.estimatedUnrealizedPnL;
-  }
-}

package/src/domain/session-builder.ts

@@ -1,158 +0,0 @@
-import {
-  AdapterAggregate,
-  AdapterFactory,
-  BacktesterListener,
-  BacktesterStreamer,
-  createBacktesterAdapterFactory,
-  createPaperAdapterFactory,
-  DefaultTimeProvider
-} from '../adapter';
-import { decimal, now } from '../shared';
-import {
-  Cache,
-  Feed,
-  inMemoryStorageFactory,
-  Measurement,
-  StorageFactory
-} from '../storage';
-import { Store } from '../store';
-import { AssetSelector } from './asset';
-import { Session } from './session';
-
-export type SessionFeature = (builder: SessionBuilder) => void;
-
-export function deposit(selector: AssetSelector, amount: decimal): SessionFeature {
-  return (builder: SessionBuilder) => {
-    builder.useBalance(selector, amount);
-  };
-}
-
-export function period(from: Date, to?: Date): SessionFeature {
-  return (builder: SessionBuilder) => {
-    builder.usePeriod(from.getTime(), to?.getTime() ?? now());
-  };
-}
-
-export class SessionBuilder {
-  public id: number = now();
-  public adapter = new Array<AdapterFactory>();
-  public storage: StorageFactory = inMemoryStorageFactory();
-  public balance: Record<string, decimal> = {};
-  public period = {
-    from: 0,
-    to: Number.MAX_VALUE
-  };
-
-  /**
-   * Unique session identifier, used to identify session in the storage.
-   * You can generate new id every time you start the new session or provide
-   * session id explicitly to resume previous session (in code or via CLI).
-   * If you don't provide session id, it will generate new one based on time.
-   */
-  useSessionId(id: number): SessionBuilder {
-    this.id = id;
-
-    return this;
-  }
-
-  /**
-   * Collection of adapters used to connect to the exchanges.
-   */
-  useAdapter(adapter: AdapterFactory): SessionBuilder {
-    this.adapter.push(adapter);
-
-    return this;
-  }
-
-  /**
-   * Provides historical data for backtest, it's not required for live and paper
-   * sessions. Stores session variables i.e. indicators, orders, or any other type of time
-   * series data. You can install @quantform/editor to render this data in your browser.
-   */
-  useStorage(storage: StorageFactory): SessionBuilder {
-    this.storage = storage;
-
-    return this;
-  }
-
-  useBalance(selector: AssetSelector, amount: decimal): SessionBuilder {
-    this.balance[selector.id] = amount;
-
-    return this;
-  }
-
-  usePeriod(from: number, to: number): SessionBuilder {
-    this.period.from = from;
-    this.period.to = to;
-
-    return this;
-  }
-
-  /**
-   * Starts a new backtest session.
-   * @param listener backtest event listener.
-   * @returns new session object.
-   */
-  backtest(listener?: BacktesterListener): [Session, BacktesterStreamer] {
-    const store = new Store();
-    const feed = new Feed(this.storage('feed'));
-    const cache = new Cache(this.storage('cache'));
-    const measurement = new Measurement(this.storage('measurement'));
-
-    const streamer = new BacktesterStreamer(store, feed, this.period, listener);
-
-    const aggregate = new AdapterAggregate(
-      this.adapter.map(it =>
-        createBacktesterAdapterFactory(
-          createPaperAdapterFactory(it, { balance: this.balance }),
-          streamer
-        )
-      ),
-      streamer.getTimeProvider(),
-      store,
-      cache
-    );
-
-    const session = new Session(this.id, store, aggregate, measurement);
-
-    return [session, streamer];
-  }
-
-  /**
-   * Starts a new paper session.
-   * @returns new session object.
-   */
-  paper(): Session {
-    const store = new Store();
-    const cache = new Cache(this.storage('cache'));
-    const measurement = new Measurement(this.storage('measurement'));
-
-    const aggregate = new AdapterAggregate(
-      this.adapter.map(it => createPaperAdapterFactory(it, { balance: this.balance })),
-      DefaultTimeProvider,
-      store,
-      cache
-    );
-
-    return new Session(this.id, store, aggregate, measurement);
-  }
-
-  /**
-   * Starts a new live session.
-   * @returns new session object.
-   */
-  live(): Session {
-    const store = new Store();
-    const cache = new Cache(this.storage('cache'));
-    const measurement = new Measurement(this.storage('measurement'));
-
-    const aggregate = new AdapterAggregate(
-      this.adapter,
-      DefaultTimeProvider,
-      store,
-      cache
-    );
-
-    return new Session(this.id, store, aggregate, measurement);
-  }
-}

package/src/domain/session.spec.ts

@@ -1,33 +0,0 @@
-import { Asset, Commission, SessionBuilder } from '../domain';
-import { d, now } from '../shared';
-import { InstrumentPatchEvent } from '../store';
-
-describe('Session', () => {
-  test('should trigger once', done => {
-    const session = new SessionBuilder().paper();
-
-    session.instruments().subscribe({
-      next: it => {
-        expect(it.length).toEqual(2);
-      },
-      complete: done()
-    });
-
-    session.store.dispatch(
-      new InstrumentPatchEvent(
-        now(),
-        new Asset('de30', 'cex', 2),
-        new Asset('usd', 'cex', 2),
-        new Commission(d.Zero, d.Zero),
-        ''
-      ),
-      new InstrumentPatchEvent(
-        now(),
-        new Asset('wig20', 'cex', 2),
-        new Asset('pln', 'cex', 2),
-        new Commission(d.Zero, d.Zero),
-        ''
-      )
-    );
-  });
-});

package/src/domain/session.ts

@@ -1,256 +0,0 @@
-import {
-  concat,
-  defer,
-  filter,
-  from,
-  map,
-  mergeMap,
-  Observable,
-  of,
-  ReplaySubject,
-  share,
-  shareReplay,
-  startWith,
-  switchMap,
-  take
-} from 'rxjs';
-import { v4 } from 'uuid';
-
-import { AdapterAggregate } from '../adapter/adapter-aggregate';
-import {
-  AssetSelector,
-  Balance,
-  Instrument,
-  InstrumentSelector,
-  invalidInstrumentSelectorError,
-  Ohlc,
-  Order,
-  Orderbook,
-  Position,
-  Trade
-} from '../domain';
-import { decimal } from '../shared';
-import { Measurement } from '../storage';
-import { Store } from '../store';
-import { balance } from './balance-operator';
-import { instrument, instruments } from './instrument-operator';
-import { order, orders } from './order-operator';
-import { orderbook } from './orderbook-operator';
-import { position, positions } from './position-operator';
-import { trade } from './trade-operator';
-
-type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
-
-export class Session {
-  private initialized = false;
-
-  get timestamp(): number {
-    return this.store.snapshot.timestamp;
-  }
-
-  constructor(
-    readonly id: number,
-    readonly store: Store,
-    readonly aggregate: AdapterAggregate,
-    readonly measurement: Measurement | undefined
-  ) {}
-
-  async awake(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-
-    this.initialized = true;
-
-    // awake all adapters and synchronize trading accounts with store.
-    await this.aggregate.awake();
-  }
-
-  async dispose(): Promise<void> {
-    if (!this.initialized) {
-      return;
-    }
-
-    this.store.dispose();
-
-    await this.aggregate.dispose();
-
-    this.initialized = false;
-  }
-
-  /**
-   * Subscribes to specific instrument. Usually forces adapter to subscribe
-   * for orderbook and ticker streams.
-   */
-  subscribe(instrument: Array<InstrumentSelector>): Promise<void> {
-    return this.aggregate.subscribe(instrument);
-  }
-
-  /**
-   * Opens a new order.
-   */
-  open(order: {
-    instrument: InstrumentSelector;
-    quantity: decimal;
-    rate?: decimal;
-  }): Observable<Readonly<Order>> {
-    const instrument = this.store.snapshot.universe.instrument.get(order.instrument.id);
-    if (!instrument) {
-      throw invalidInstrumentSelectorError(order.instrument.id);
-    }
-
-    const newOrder = new Order(
-      this.timestamp,
-      v4(),
-      instrument,
-      order.quantity,
-      this.timestamp,
-      order.rate
-    );
-
-    return of(newOrder).pipe(
-      switchMap(() => this.aggregate.open(newOrder)),
-      switchMap(() =>
-        this.order(order.instrument).pipe(filter(it => it.id == newOrder.id))
-      )
-    );
-  }
-
-  /**
-   * Cancels specific order.
-   */
-  cancel(order: Order): Observable<Readonly<Order>> {
-    return defer(() => from(this.aggregate.cancel(order))).pipe(
-      switchMap(() => this.order(order.instrument).pipe(filter(it => it.id == order.id)))
-    );
-  }
-
-  /**
-   * Subscribes to specific instrument changes.
-   * When adapter awake then it will fetch collection of all available instruments.
-   */
-  instrument(selector: InstrumentSelector): Observable<Readonly<Instrument>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(instrument(selector, this.store.snapshot));
-  }
-
-  /**
-   * Subscribes to instruments changes.
-   * When adapter awake then it will fetch collection of all available instruments.
-   */
-  instruments(): Observable<Readonly<Instrument[]>> {
-    return this.store.changes$.pipe(instruments(this.store.snapshot));
-  }
-
-  /**
-   * Subscribes to balance changes.
-   */
-  balance(selector: AssetSelector): Observable<Readonly<Balance>> {
-    return this.store.changes$.pipe(balance(selector, this.store.snapshot));
-  }
-
-  /**
-   * Subscribes to trade/ticker changes.
-   */
-  trade(selector: InstrumentSelector): Observable<Readonly<Trade>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(trade(selector, this.store.snapshot));
-  }
-
-  /**
-   * Subscribes to orderbook changes.
-   * Right now you can access only best bid and best ask.
-   */
-  orderbook(selector: InstrumentSelector): Observable<Readonly<Orderbook>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(orderbook(selector, this.store.snapshot));
-  }
-
-  /**
-   * Subscribes to position on leveraged market.
-   */
-  position(selector: InstrumentSelector): Observable<Readonly<Position>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(position(selector));
-  }
-
-  /**
-   * Subscribes to positions on leveraged markets.
-   */
-  positions(selector: InstrumentSelector): Observable<Readonly<Position[]>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(positions(selector, this.store.snapshot));
-  }
-
-  order(selector: InstrumentSelector): Observable<Readonly<Order>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(order(selector));
-  }
-
-  orders(selector: InstrumentSelector): Observable<Readonly<Order[]>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(orders(selector, this.store.snapshot));
-  }
-
-  history(
-    selector: InstrumentSelector,
-    timeframe: number,
-    length: number
-  ): Observable<Readonly<Ohlc>> {
-    return this.store.changes$.pipe(
-      startWith(this.store.snapshot.universe.instrument.get(selector.id)),
-      filter(it => it instanceof Instrument && it.id == selector.id),
-      switchMap(() => from(this.aggregate.history(selector, timeframe, length))),
-      take(1),
-      shareReplay(),
-      mergeMap(it => it)
-    );
-  }
-
-  measure<T extends { timestamp: number }>(
-    spec: {
-      kind: string;
-      timestamp?: number;
-    },
-    defaultValue?: Optional<T, 'timestamp'>
-  ): [Observable<T>, (value: T) => void] {
-    if (!this.measurement) {
-      throw new Error();
-    }
-
-    const changes$ = new ReplaySubject<Optional<T, 'timestamp'>>();
-    const persisted$ = from(
-      this.measurement.query(this.id, {
-        to: spec.timestamp ?? this.timestamp,
-        kind: spec.kind,
-        count: 1
-      })
-    ).pipe(
-      map(it =>
-        it.length ? { timestamp: it[0].timestamp, ...it[0].payload } : defaultValue
-      ),
-      share()
-    );
-
-    const setter = (value: Optional<T, 'timestamp'>) => {
-      const timestamp = value.timestamp ?? this.timestamp;
-      const measure = { timestamp, kind: spec.kind, payload: value };
-
-      this.measurement?.save(this.id, [measure]);
-
-      changes$.next({ ...value, timestamp });
-    };
-
-    return [
-      concat(persisted$, changes$.asObservable()).pipe(filter(it => it !== undefined)),
-      setter
-    ];
-  }
-}

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

@@ -1,35 +0,0 @@
-import { Subject } from 'rxjs';
-
-import { d } from '../shared';
-import { State } from '../store';
-import { Asset } from './asset';
-import { Commission } from './commission';
-import { Component } from './component';
-import { Instrument } from './instrument';
-import { Trade } from './trade';
-import { trade } from './trade-operator';
-
-describe('trade', () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('abc', 'xyz', 4),
-    new Asset('def', 'xyz', 4),
-    'abc-def',
-    Commission.Zero
-  );
-
-  const state = new State();
-
-  beforeEach(() => {
-    state.trade.upsert(new Trade(0, instrument, d.Zero, d.Zero));
-  });
-
-  test('should pipe an orderbook on subscription', done => {
-    new Subject<Component>().pipe(trade(instrument, state)).subscribe({
-      next: it => {
-        expect(it.id).toEqual(instrument.id);
-        done();
-      }
-    });
-  });
-});

package/src/domain/trade-operator.ts

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

package/src/domain/trade.spec.ts

@@ -1,21 +0,0 @@
-import { d } from '../shared';
-import { Asset } from './asset';
-import { Commission } from './commission';
-import { Instrument } from './instrument';
-import { Trade } from './trade';
-
-describe('Trade', () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('abc', 'xyz', 4),
-    new Asset('def', 'xyz', 4),
-    'abc-def',
-    Commission.Zero
-  );
-
-  test('should construct an empty trade', () => {
-    const sut = new Trade(0, instrument, d.Zero, d.Zero);
-
-    expect(sut.id).toEqual(instrument.id);
-  });
-});

package/src/domain/trade.ts

@@ -1,20 +0,0 @@
-import { decimal } from '../shared';
-import { Instrument } from '.';
-import { Component } from './component';
-
-/**
- * Simple trade or ticker executed on the market, it's a match of buyer
- * and seller of the same asset.
- */
-export class Trade implements Component {
-  readonly id: string;
-
-  constructor(
-    public timestamp: number,
-    public readonly instrument: Instrument,
-    public rate: decimal,
-    public quantity: decimal
-  ) {
-    this.id = instrument.id;
-  }
-}