@quantform/core 0.5.23 → 0.6.4

package/src/domain/order.ts

@@ -1,12 +1,9 @@
-import { v4 } from 'uuid';
-
-import { d, decimal, timestamp } from '../shared';
+import { d, decimal } from '../shared';
 import { Balance } from './balance';
 import { Component } from './component';
 import { invalidArgumentError } from './error';
-import { InstrumentSelector } from './instrument';
+import { Instrument } from './instrument';
 
-export type OrderType = 'MARKET' | 'LIMIT' | 'STOP-MARKET' | 'STOP-LIMIT';
 export type OrderState =
   | 'NEW'
   | 'PENDING'
@@ -16,45 +13,18 @@ export type OrderState =
   | 'REJECTED';
 
 export class Order implements Component {
-  kind = 'order';
-  timestamp: timestamp;
-  id = v4();
-  externalId: string;
+  readonly kind = 'order';
   state: OrderState = 'NEW';
-
   quantityExecuted = d.Zero;
-  averageExecutionRate: decimal;
-  createdAt: timestamp;
-
-  static market(instrument: InstrumentSelector, quantity: decimal): Order {
-    return new Order(instrument, 'MARKET', quantity);
-  }
-
-  static limit(instrument: InstrumentSelector, quantity: decimal, rate: decimal): Order {
-    return new Order(instrument, 'LIMIT', quantity, rate);
-  }
-
-  static stopMarket(
-    instrument: InstrumentSelector,
-    quantity: decimal,
-    stopRate: decimal
-  ): Order {
-    return new Order(instrument, 'STOP-MARKET', quantity, undefined, stopRate);
-  }
-
-  static stopLimit(
-    instrument: InstrumentSelector,
-    quantity: decimal,
-    rate: decimal,
-    stopRate: decimal
-  ): Order {
-    return new Order(instrument, 'STOP-LIMIT', quantity, rate, stopRate);
-  }
+  averageExecutionRate?: decimal;
+  externalId?: string;
 
   constructor(
-    readonly instrument: InstrumentSelector,
-    readonly type: OrderType,
+    public timestamp: number,
+    readonly id: string,
+    readonly instrument: Instrument,
     readonly quantity: decimal,
+    public createdAt: number,
     readonly rate?: decimal,
     readonly stopRate?: decimal
   ) {
@@ -74,22 +44,20 @@ export class Order implements Component {
   calculateBalanceToLock(
     base: Balance,
     quote: Balance
-  ): { base: decimal; quote: decimal } {
+  ): { base?: decimal; quote?: decimal } {
     const qty = this.quantity.abs();
 
     if (this.quantity.greaterThan(0)) {
-      switch (this.type) {
-        case 'MARKET':
-          return {
-            base: d.Zero,
-            quote: quote.free
-          };
-
-        case 'LIMIT':
-          return {
-            base: d.Zero,
-            quote: quote.asset.ceil(this.rate.mul(qty))
-          };
+      if (this.rate) {
+        return {
+          base: d.Zero,
+          quote: quote.asset.ceil(this.rate.mul(qty))
+        };
+      } else {
+        return {
+          base: d.Zero,
+          quote: quote.free
+        };
       }
     }
 
@@ -99,5 +67,7 @@ export class Order implements Component {
         quote: d.Zero
       };
     }
+
+    return {};
   }
 }

package/src/domain/{orderbook.operator.spec.ts → orderbook-operator.spec.ts}

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

package/src/domain/orderbook.spec.ts

@@ -1,16 +1,25 @@
+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'
+    'abc-def',
+    Commission.Zero
   );
 
   test('should construct an empty orderbook', () => {
-    const sut = new Orderbook(instrument);
+    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,11 +1,11 @@
 import { Instrument } from '../domain';
-import { decimal, timestamp } from '../shared';
+import { decimal } from '../shared';
 import { Component } from './component';
 
 export interface Liquidity {
   rate: decimal;
   quantity: decimal;
-  next: this;
+  next: this | undefined;
 }
 
 export const LiquidityAskComparer = (lhs: { rate: decimal }, rhs: { rate: decimal }) =>
@@ -17,14 +17,15 @@ export const LiquidityBidComparer = (lhs: { rate: decimal }, rhs: { rate: decima
  * Provides an access to pending buy and sell orders on the specific market.
  */
 export class Orderbook implements Component {
-  id: string;
-  kind = 'orderbook';
-  timestamp: timestamp;
+  readonly id: string;
+  readonly kind = 'orderbook';
 
-  asks: Liquidity;
-  bids: Liquidity;
-
-  constructor(public readonly instrument: Instrument) {
+  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 → position-operator.spec.ts}

@@ -4,20 +4,25 @@ 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';
+import { position, positions } from './position-operator';
 
 const instrument = new Instrument(
+  0,
   new Asset('abc', 'xyz', 4),
   new Asset('def', 'xyz', 4),
-  'abc-def'
+  'abc-def',
+  Commission.Zero
 );
 
 describe('position', () => {
   test('should pipe a position', done => {
-    new BehaviorSubject<Component>(new Position('1', instrument, 'CROSS', d(10), d(2), 3))
+    new BehaviorSubject<Component>(
+      new Position(0, '1', instrument, 'CROSS', d(10), d(2), 3)
+    )
       .pipe(position(instrument))
       .subscribe({
         next: it => {
@@ -37,9 +42,9 @@ describe('position', () => {
 
 describe('positions', () => {
   const state = new State();
-  const balance = new Balance(instrument.quote);
-  const position1 = new Position('1', instrument, 'CROSS', d(10), d(2), 3);
-  const position2 = new Position('2', instrument, 'CROSS', d(20), d(2), 3);
+  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);

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

@@ -2,24 +2,31 @@ 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<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()),

package/src/domain/position.spec.ts

@@ -1,17 +1,20 @@
 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', d(10), d(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');
@@ -23,14 +26,14 @@ describe('Position', () => {
   });
 
   test('should calculate correct margin', () => {
-    const sut = new Position('1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
+    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('1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
+    const sut = new Position(0, '1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
 
     const pnl = sut.calculateEstimatedUnrealizedPnL(d(2576.44));
 

package/src/domain/position.ts

@@ -1,12 +1,11 @@
 import { Instrument } from '../domain';
-import { decimal, 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;
+  readonly kind = 'position';
   estimatedUnrealizedPnL?: decimal;
 
   get margin(): decimal {
@@ -14,6 +13,7 @@ export class Position implements Component {
   }
 
   constructor(
+    public timestamp: number,
     readonly id: string,
     readonly instrument: Instrument,
     readonly mode: PositionMode,

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 { 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 => {