@quantform/core 0.6.6 → 0.7.0-beta.10

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

@@ -1,40 +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 { Orderbook } from './orderbook';
-import { orderbook } from './orderbook-operator';
-
-describe('orderbook', () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('abc', 'xyz', 4),
-    new Asset('def', 'xyz', 4),
-    'abc-def',
-    Commission.Zero
-  );
-
-  test('should pipe an orderbook on subscription', done => {
-    const state = new State();
-
-    state.orderbook.upsert(
-      new Orderbook(
-        0,
-        instrument,
-        { rate: d(2), quantity: d(1), next: undefined },
-        { rate: d(1), quantity: d(1), next: undefined }
-      )
-    );
-
-    new Subject<Component>().pipe(orderbook(instrument, state)).subscribe({
-      next: it => {
-        expect(it.id).toEqual(instrument.id);
-        done();
-      }
-    });
-  });
-});

package/src/domain/orderbook-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 { Orderbook } from './orderbook';
-
-export function orderbook(selector: InstrumentSelector, state: State) {
-  return (source$: Observable<Component>) =>
-    source$.pipe(
-      startWith(state.orderbook.get(selector.id)),
-      filter(it => it instanceof Orderbook && it.instrument.id == selector.id),
-      map(it => it as Orderbook)
-    );
-}

package/src/domain/orderbook.spec.ts

@@ -1,26 +0,0 @@
-import { d } from '../shared';
-import { Asset } from './asset';
-import { Commission } from './commission';
-import { Instrument } from './instrument';
-import { Orderbook } from './orderbook';
-
-describe('Orderbook', () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('abc', 'xyz', 4),
-    new Asset('def', 'xyz', 4),
-    'abc-def',
-    Commission.Zero
-  );
-
-  test('should construct an empty orderbook', () => {
-    const sut = new Orderbook(
-      0,
-      instrument,
-      { rate: d(2), quantity: d(1), next: undefined },
-      { rate: d(1), quantity: d(1), next: undefined }
-    );
-
-    expect(sut.id).toEqual(instrument.id);
-  });
-});

package/src/domain/orderbook.ts

@@ -1,30 +0,0 @@
-import { Instrument } from '../domain';
-import { decimal } from '../shared';
-import { Component } from './component';
-
-export interface Liquidity {
-  rate: decimal;
-  quantity: decimal;
-  next: this | undefined;
-}
-
-export const LiquidityAskComparer = (lhs: { rate: decimal }, rhs: { rate: decimal }) =>
-  lhs.rate.comparedTo(rhs.rate);
-export const LiquidityBidComparer = (lhs: { rate: decimal }, rhs: { rate: decimal }) =>
-  rhs.rate.comparedTo(lhs.rate);
-
-/**
- * Provides an access to pending buy and sell orders on the specific market.
- */
-export class Orderbook implements Component {
-  readonly id: string;
-
-  constructor(
-    public timestamp: number,
-    public readonly instrument: Instrument,
-    public asks: Liquidity,
-    public bids: Liquidity
-  ) {
-    this.id = instrument.id;
-  }
-}

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

@@ -1,64 +0,0 @@
-import { BehaviorSubject, Subject } from 'rxjs';
-
-import { d } from '../shared';
-import { State } from '../store';
-import { Asset } from './asset';
-import { Balance } from './balance';
-import { Commission } from './commission';
-import { Component } from './component';
-import { Instrument } from './instrument';
-import { Position } from './position';
-import { position, positions } from './position-operator';
-
-const instrument = new Instrument(
-  0,
-  new Asset('abc', 'xyz', 4),
-  new Asset('def', 'xyz', 4),
-  'abc-def',
-  Commission.Zero
-);
-
-describe('position', () => {
-  test('should pipe a position', done => {
-    new BehaviorSubject<Component>(
-      new Position(0, '1', instrument, 'CROSS', d(10), d(2), 3)
-    )
-      .pipe(position(instrument))
-      .subscribe({
-        next: it => {
-          expect(it.id).toEqual('1');
-          done();
-        }
-      });
-  });
-
-  test('should skip a pipe', done => {
-    new BehaviorSubject<Component>(instrument).pipe(position(instrument)).subscribe({
-      next: () => fail(),
-      complete: done()
-    });
-  });
-});
-
-describe('positions', () => {
-  const state = new State();
-  const balance = new Balance(0, instrument.quote);
-  const position1 = new Position(0, '1', instrument, 'CROSS', d(10), d(2), 3);
-  const position2 = new Position(0, '2', instrument, 'CROSS', d(20), d(2), 3);
-
-  beforeEach(() => {
-    state.balance.upsert(balance);
-
-    balance.position['1'] = position1;
-    balance.position['2'] = position2;
-  });
-
-  test('should pipe an array of positions on subscription start', done => {
-    new Subject<Component>().pipe(positions(instrument, state)).subscribe({
-      next: it => {
-        expect(it.length).toEqual(2);
-        done();
-      }
-    });
-  });
-});

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),
-        ''
-      )
-    );
-  });
-});