@quantform/core 0.5.15 → 0.6.4

package/src/domain/{position.operator.ts → position-operator.ts}

@@ -1,25 +1,32 @@
 import { filter, map, Observable, share, startWith } from 'rxjs';
 
-import { weightedMean } from '../shared';
+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<Position>) =>
+  return (source: Observable<Component>) =>
     source.pipe(
-      filter(it => it.kind == 'position' && it.instrument.id == selector.id),
+      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(state.balance.get(selector.quote.id).position).filter(
-      it => it.instrument.id == selector.id
-    );
+    Object.values(balance.position)
+      .filter(it => it.instrument.id == selector.id)
+      .map(it => it as Readonly<Position>);
 
-  return (source: Observable<Position>) =>
+  return (source: Observable<Component>) =>
     source.pipe(
       position(selector),
       map(() => getter()),
@@ -30,12 +37,15 @@ export function positions(selector: InstrumentSelector, state: State) {
 export function flatten() {
   return function (
     source: Observable<Position[]>
-  ): Observable<{ size: number; rate: number }> {
+  ): Observable<{ size: decimal; rate: decimal }> {
     return source.pipe(
       map(it => {
         if (it.length > 1) {
           return {
-            size: it.reduce((aggregate, position) => aggregate + position.size, 0),
+            size: it.reduce(
+              (aggregate, position) => aggregate.add(position.size),
+              d.Zero
+            ),
             rate: weightedMean(
               it.map(x => x.averageExecutionRate),
               it.map(x => x.size)
@@ -51,8 +61,8 @@ export function flatten() {
         }
 
         return {
-          size: 0,
-          rate: 0
+          size: d.Zero,
+          rate: d.Zero
         };
       }),
       share()

package/src/domain/position.spec.ts

@@ -1,39 +1,43 @@
+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'
+    'abc-def',
+    Commission.Zero
   );
 
   test('should construct a position', () => {
-    const sut = new Position('1', instrument, 'CROSS', 10, 2, 3);
+    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(10);
-    expect(sut.size).toEqual(2);
+    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('1', instrument, 'CROSS', 2511.81, 10.31, 20);
+    const sut = new Position(0, '1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
 
-    expect(sut.margin).toEqual(0.5155);
+    expect(sut.margin).toEqual(d(0.5155));
     expect(sut.estimatedUnrealizedPnL).toEqual(undefined);
   });
 
   test('should calculate correct unrealized pnl', () => {
-    const sut = new Position('1', instrument, 'CROSS', 2511.81, 10.31, 20);
+    const sut = new Position(0, '1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
 
-    const pnl = sut.calculateEstimatedUnrealizedPnL(2576.44);
+    const pnl = sut.calculateEstimatedUnrealizedPnL(d(2576.44));
 
-    expect(pnl).toEqual(0.2652);
-    expect(sut.estimatedUnrealizedPnL).toEqual(0.2652);
+    expect(pnl).toEqual(d(0.2652));
+    expect(sut.estimatedUnrealizedPnL).toEqual(d(0.2652));
   });
 });

package/src/domain/position.ts

@@ -1,29 +1,29 @@
 import { Instrument } from '../domain';
-import { pnl, timestamp } from '../shared';
+import { decimal, pnl } from '../shared';
 import { Component } from './component';
 
 export type PositionMode = 'CROSS' | 'ISOLATED';
 
 export class Position implements Component {
-  kind = 'position';
-  timestamp: timestamp;
-  estimatedUnrealizedPnL?: number;
+  readonly kind = 'position';
+  estimatedUnrealizedPnL?: decimal;
 
-  get margin(): number {
-    return this.instrument.quote.fixed(Math.abs(this.size) / this.leverage);
+  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: number,
-    public size: number,
+    public averageExecutionRate: decimal,
+    public size: decimal,
     public leverage: number
   ) {}
 
-  calculateEstimatedUnrealizedPnL(rate: number): number {
-    this.estimatedUnrealizedPnL = this.instrument.quote.fixed(
+  calculateEstimatedUnrealizedPnL(rate: decimal): decimal {
+    this.estimatedUnrealizedPnL = this.instrument.quote.floor(
       pnl(this.averageExecutionRate, rate, this.size)
     );
 

package/src/domain/session-builder.ts

@@ -0,0 +1,158 @@
+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());
+  };
+}
+
+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.toString()] = 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,17 +1,10 @@
-import { Bootstrap } from '../bootstrap';
-import { Asset, Commission } from '../domain';
-import { now } from '../shared';
+import { Asset, Commission, SessionBuilder } from '../domain';
+import { d, now } from '../shared';
 import { InstrumentPatchEvent } from '../store';
-import { SessionDescriptor } from './session';
 
 describe('Session', () => {
-  const descriptor: SessionDescriptor = {
-    id: now(),
-    adapter: []
-  };
-
   test('should trigger once', done => {
-    const session = new Bootstrap(descriptor).paper();
+    const session = new SessionBuilder().paper();
 
     session.instruments().subscribe({
       next: it => {
@@ -25,14 +18,14 @@ describe('Session', () => {
         now(),
         new Asset('de30', 'cex', 2),
         new Asset('usd', 'cex', 2),
-        new Commission(0, 0),
+        new Commission(d.Zero, d.Zero),
         ''
       ),
       new InstrumentPatchEvent(
         now(),
         new Asset('wig20', 'cex', 2),
         new Asset('pln', 'cex', 2),
-        new Commission(0, 0),
+        new Commission(d.Zero, d.Zero),
         ''
       )
     );

package/src/domain/session.ts

@@ -1,19 +1,21 @@
 import {
+  concat,
   defer,
   filter,
-  finalize,
   from,
   map,
   mergeMap,
   Observable,
+  of,
+  ReplaySubject,
+  share,
   shareReplay,
   startWith,
-  Subscription,
   switchMap,
   take
 } from 'rxjs';
+import { v4 } from 'uuid';
 
-import { AdapterFactory, BacktesterOptions, PaperOptions } from '../adapter';
 import { AdapterAggregate } from '../adapter/adapter-aggregate';
 import {
   AssetSelector,
@@ -21,71 +23,39 @@ import {
   Candle,
   Instrument,
   InstrumentSelector,
+  invalidInstrumentSelectorError,
   Order,
   Orderbook,
   Position,
   Trade
 } from '../domain';
-import { now } from '../shared';
-import { StorageFactory } from '../storage';
+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';
-
-/**
- * Describes a single session.
- */
-export interface SessionDescriptor {
-  /**
-   * 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.
-   */
-  id?: number;
-
-  /**
-   * Collection of adapters used to connect to the exchanges.
-   */
-  adapter: AdapterFactory[];
+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';
 
-  /**
-   * 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.
-   */
-  storage?: StorageFactory;
-
-  /**
-   * Session additional options.
-   */
-  simulation?: PaperOptions & BacktesterOptions;
-}
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
 
 export class Session {
   private initialized = false;
-  private subscription: Subscription;
 
   get timestamp(): number {
     return this.store.snapshot.timestamp;
   }
 
   constructor(
+    readonly id: number,
     readonly store: Store,
     readonly aggregate: AdapterAggregate,
-    readonly descriptor?: SessionDescriptor
-  ) {
-    // generate session id based on time if not provided.
-    if (descriptor && !descriptor.id) {
-      descriptor.id = now();
-    }
-  }
+    readonly measurement: Measurement | undefined
+  ) { }
 
-  async awake(describe: (session: Session) => Observable<any>): Promise<void> {
+  async awake(): Promise<void> {
     if (this.initialized) {
       return;
     }
@@ -94,12 +64,6 @@ export class Session {
 
     // awake all adapters and synchronize trading accounts with store.
     await this.aggregate.awake();
-
-    if (describe) {
-      this.subscription = describe(this)
-        .pipe(finalize(() => this.dispose()))
-        .subscribe();
-    }
   }
 
   async dispose(): Promise<void> {
@@ -107,11 +71,6 @@ export class Session {
       return;
     }
 
-    if (this.subscription) {
-      this.subscription.unsubscribe();
-      this.subscription = undefined;
-    }
-
     this.store.dispose();
 
     await this.aggregate.dispose();
@@ -129,12 +88,31 @@ export class Session {
 
   /**
    * Opens a new order.
-   * Example of buy order:
-   * session.open(Order.market(instrument, 100));
    */
-  open(order: Order): Observable<Readonly<Order>> {
-    return from(this.aggregate.open(order)).pipe(
-      switchMap(() => this.order(order.instrument).pipe(filter(it => it.id == order.id)))
+  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))
+      )
     );
   }
 
@@ -143,10 +121,7 @@ export class Session {
    */
   cancel(order: Order): Observable<Readonly<Order>> {
     return defer(() => from(this.aggregate.cancel(order))).pipe(
-      switchMap(() =>
-        this.store.changes$.pipe(filter(it => it instanceof Order && order.id == it.id))
-      ),
-      map(it => it as Order)
+      switchMap(() => this.order(order.instrument).pipe(filter(it => it.id == order.id)))
     );
   }
 
@@ -232,12 +207,50 @@ export class Session {
     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({ instrument: selector, timeframe, length }))
-      ),
+      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 → trade-operator.spec.ts}

@@ -1,23 +1,27 @@
 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';
+import { trade } from './trade-operator';
 
 describe('trade', () => {
   const instrument = new Instrument(
+    0,
     new Asset('abc', 'xyz', 4),
     new Asset('def', 'xyz', 4),
-    'abc-def'
+    'abc-def',
+    Commission.Zero
   );
 
   const state = new State();
 
   beforeEach(() => {
-    state.trade.upsert(new Trade(instrument));
+    state.trade.upsert(new Trade(0, instrument, d.Zero, d.Zero));
   });
 
   test('should pipe an orderbook on subscription', done => {

package/src/domain/trade.spec.ts

@@ -1,16 +1,20 @@
+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'
+    'abc-def',
+    Commission.Zero
   );
 
   test('should construct an empty trade', () => {
-    const sut = new Trade(instrument);
+    const sut = new Trade(0, instrument, d.Zero, d.Zero);
 
     expect(sut.id).toEqual(instrument.id);
   });

package/src/domain/trade.ts

@@ -1,4 +1,4 @@
-import { timestamp } from '../shared';
+import { decimal } from '../shared';
 import { Instrument } from '.';
 import { Component } from './component';
 
@@ -7,13 +7,15 @@ import { Component } from './component';
  * and seller of the same asset.
  */
 export class Trade implements Component {
-  id: string;
-  kind = 'trade';
-  timestamp: timestamp;
-  rate: number;
-  quantity: number;
+  readonly id: string;
+  readonly kind = 'trade';
 
-  constructor(public readonly instrument: Instrument) {
+  constructor(
+    public timestamp: number,
+    public readonly instrument: Instrument,
+    public rate: decimal,
+    public quantity: decimal
+  ) {
     this.id = instrument.id;
   }
 

package/src/index.ts

@@ -1,7 +1,6 @@
 export * from './adapter';
-export * from './bootstrap';
 export * from './domain';
-export * from './indicator';
 export * from './shared';
 export * from './storage';
 export * from './store';
+export * from './strategy';