@quantform/core 0.5.13 → 0.5.23

package/src/domain/orderbook.ts

@@ -1,23 +1,32 @@
 import { Instrument } from '../domain';
-import { timestamp } from '../shared';
+import { decimal, timestamp } from '../shared';
 import { Component } from './component';
 
+export interface Liquidity {
+  rate: decimal;
+  quantity: decimal;
+  next: this;
+}
+
+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 {
+  id: string;
   kind = 'orderbook';
   timestamp: timestamp;
-  bestAskRate: number;
-  bestAskQuantity: number;
-  bestBidRate: number;
-  bestBidQuantity: number;
 
-  get midRate(): number {
-    return this.instrument.quote.fixed((this.bestAskRate + this.bestBidRate) / 2);
-  }
+  asks: Liquidity;
+  bids: Liquidity;
 
-  constructor(public readonly instrument: Instrument) {}
+  constructor(public readonly instrument: Instrument) {
+    this.id = instrument.id;
+  }
 
   toString() {
     return this.instrument.toString();

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

@@ -0,0 +1,59 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+
+import { d } from '../shared';
+import { State } from '../store';
+import { Asset } from './asset';
+import { Balance } from './balance';
+import { Component } from './component';
+import { Instrument } from './instrument';
+import { Position } from './position';
+import { position, positions } from './position.operator';
+
+const instrument = new Instrument(
+  new Asset('abc', 'xyz', 4),
+  new Asset('def', 'xyz', 4),
+  'abc-def'
+);
+
+describe('position', () => {
+  test('should pipe a position', done => {
+    new BehaviorSubject<Component>(new Position('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(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);
+
+  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

@@ -0,0 +1,64 @@
+import { filter, map, Observable, share, startWith } from 'rxjs';
+
+import { d, decimal, weightedMean } from '../shared';
+import { State } from '../store';
+import { InstrumentSelector } from './instrument';
+import { Position } from './position';
+
+export function position(selector: InstrumentSelector) {
+  return (source: Observable<Position>) =>
+    source.pipe(
+      filter(it => it.kind == 'position' && it.instrument.id == selector.id),
+      map(it => it as Readonly<Position>)
+    );
+}
+
+export function positions(selector: InstrumentSelector, state: State) {
+  const getter = () =>
+    Object.values(state.balance.get(selector.quote.id).position).filter(
+      it => it.instrument.id == selector.id
+    );
+
+  return (source: Observable<Position>) =>
+    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,35 +1,40 @@
+import { d } from '../shared';
 import { Asset } from './asset';
 import { Instrument } from './instrument';
 import { Position } from './position';
 
-const instrument = new Instrument(
-  new Asset('abc', 'xyz', 4),
-  new Asset('def', 'xyz', 4),
-  'abc-def'
-);
-
-describe('position tests', () => {
-  test('should instantiate proper position', () => {
-    const sut = new Position('123', instrument);
+describe('Position', () => {
+  const instrument = new Instrument(
+    new Asset('abc', 'xyz', 4),
+    new Asset('def', 'xyz', 4),
+    'abc-def'
+  );
+
+  test('should construct a position', () => {
+    const sut = new Position('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');
+  });
 
-    sut.size = 5;
-    sut.averageExecutionRate = 20;
-    sut.leverage = 20;
+  test('should calculate correct margin', () => {
+    const sut = new Position('1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
 
-    expect(sut.margin).toEqual(5);
-    expect(sut.estimatedUnrealizedPnL).toEqual(0);
+    expect(sut.margin).toEqual(d(0.5155));
+    expect(sut.estimatedUnrealizedPnL).toEqual(undefined);
   });
 
-  test('should calculate unrealized pnl', () => {
-    const sut = new Position('123', instrument);
-
-    sut.size = -5;
-    sut.averageExecutionRate = 20;
-    sut.leverage = 20;
+  test('should calculate correct unrealized pnl', () => {
+    const sut = new Position('1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
 
-    sut.calculatePnL(10);
+    const pnl = sut.calculateEstimatedUnrealizedPnL(d(2576.44));
 
-    expect(sut.margin).toEqual(5);
-    expect(sut.estimatedUnrealizedPnL).toEqual(50);
+    expect(pnl).toEqual(d(0.2652));
+    expect(sut.estimatedUnrealizedPnL).toEqual(d(0.2652));
   });
 });

package/src/domain/position.ts

@@ -1,7 +1,5 @@
-import { map, Observable, share } from 'rxjs';
-
 import { Instrument } from '../domain';
-import { pnl, timestamp, weightedMean } from '../shared';
+import { decimal, pnl, timestamp } from '../shared';
 import { Component } from './component';
 
 export type PositionMode = 'CROSS' | 'ISOLATED';
@@ -9,22 +7,25 @@ export type PositionMode = 'CROSS' | 'ISOLATED';
 export class Position implements Component {
   kind = 'position';
   timestamp: timestamp;
-  averageExecutionRate: number;
-  size: number;
-  leverage: number;
-  mode: PositionMode = 'CROSS';
-  estimatedUnrealizedPnL = 0;
+  estimatedUnrealizedPnL?: decimal;
 
-  get margin(): number {
-    return this.instrument.quote.ceil(
-      (Math.abs(this.size) * this.averageExecutionRate) / this.leverage
-    );
+  get margin(): decimal {
+    return this.instrument.quote.floor(this.size.abs().div(this.leverage));
   }
 
-  constructor(readonly id: string, readonly instrument: Instrument) {}
-
-  calculatePnL(rate: number): number {
-    this.estimatedUnrealizedPnL = pnl(this.averageExecutionRate, rate, this.size);
+  constructor(
+    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;
   }
@@ -33,36 +34,3 @@ export class Position implements Component {
     return this.id;
   }
 }
-
-export function positionsFlat() {
-  return function (
-    source: Observable<Position[]>
-  ): Observable<{ size: number; rate: number }> {
-    return source.pipe(
-      map(it => {
-        if (it.length > 1) {
-          return {
-            size: it.reduce((aggregate, position) => aggregate + position.size, 0),
-            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: 0,
-          rate: 0
-        };
-      }),
-      share()
-    );
-  };
-}

package/src/domain/session.spec.ts

@@ -1,10 +1,10 @@
 import { Bootstrap } from '../bootstrap';
 import { Asset, Commission } from '../domain';
-import { now } from '../shared';
+import { d, now } from '../shared';
 import { InstrumentPatchEvent } from '../store';
 import { SessionDescriptor } from './session';
 
-describe('session tests', () => {
+describe('Session', () => {
   const descriptor: SessionDescriptor = {
     id: now(),
     adapter: []
@@ -25,14 +25,14 @@ describe('session tests', () => {
         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,22 +1,19 @@
 import {
   defer,
-  distinctUntilChanged,
   filter,
   finalize,
   from,
   map,
-  merge,
   mergeMap,
   Observable,
   shareReplay,
   startWith,
-  Subject,
   Subscription,
   switchMap,
   take
 } from 'rxjs';
 
-import { Adapter, BacktesterOptions, PaperOptions } from '../adapter';
+import { AdapterFactory, BacktesterOptions, PaperOptions } from '../adapter';
 import { AdapterAggregate } from '../adapter/adapter-aggregate';
 import {
   AssetSelector,
@@ -26,26 +23,21 @@ import {
   InstrumentSelector,
   Order,
   Orderbook,
-  OrderState,
   Position,
   Trade
 } from '../domain';
 import { now } from '../shared';
 import { StorageFactory } 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.
- * You can use @run function to start a new session managed by CLI.
- * To start managed session you should install @quantform/cli package and run
- * specific command:
- *  - qf paper (to paper trade strategy)
- *  - qf backtest (to backtest strategy based on provided feed)
- *  - qf live (to live trade strategy)
- * or run on your own in code:
- *  - paper(descriptor, options)
- *  - backtest(descriptor, options)
- *  - live(descriptor)
  */
 export interface SessionDescriptor {
   /**
@@ -59,7 +51,7 @@ export interface SessionDescriptor {
   /**
    * Collection of adapters used to connect to the exchanges.
    */
-  adapter: Adapter[];
+  adapter: AdapterFactory[];
 
   /**
    * Provides historical data for backtest, it's not required for live and paper
@@ -82,8 +74,6 @@ export class Session {
     return this.store.snapshot.timestamp;
   }
 
-  readonly statement: Record<string, Record<string, any>> = {};
-
   constructor(
     readonly store: Store,
     readonly aggregate: AdapterAggregate,
@@ -129,19 +119,6 @@ export class Session {
     this.initialized = false;
   }
 
-  useStatement(section: string): Record<string, any> {
-    return this.statement[section] ?? (this.statement[section] = {});
-  }
-
-  /**
-   * Return values for patch provided in optimization file.
-   * Example usage:
-   * const orderSize = session.useOptimizer('order.size');
-   */
-  useOptimizer(path: string): any {
-    return undefined;
-  }
-
   /**
    * Subscribes to specific instrument. Usually forces adapter to subscribe
    * for orderbook and ticker streams.
@@ -152,26 +129,21 @@ export class Session {
 
   /**
    * Opens a new order.
-   * Example:
-   * session.open(Order.buyMarket(instrument, 100));
+   * Example of buy order:
+   * session.open(Order.market(instrument, 100));
    */
-  open(order: Order): Observable<Order> {
-    const subject = new Subject<Order>();
-
-    this.aggregate.open(order).catch(subject.error);
-
-    return merge(
-      subject.asObservable(),
-      this.order(order.instrument).pipe(filter(it => it.id == order.id))
+  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)))
     );
   }
 
   /**
    * Cancels specific order.
    */
-  cancel(order: Order): Observable<Order> {
+  cancel(order: Order): Observable<Readonly<Order>> {
     return defer(() => from(this.aggregate.cancel(order))).pipe(
-      switchMap(it =>
+      switchMap(() =>
         this.store.changes$.pipe(filter(it => it instanceof Order && order.id == it.id))
       ),
       map(it => it as Order)
@@ -182,149 +154,85 @@ export class Session {
    * Subscribes to specific instrument changes.
    * When adapter awake then it will fetch collection of all available instruments.
    */
-  instrument(selector: InstrumentSelector): Observable<Instrument> {
+  instrument(selector: InstrumentSelector): Observable<Readonly<Instrument>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(it => it instanceof Instrument && it.toString() == selector.toString()),
-      map(it => it as Instrument)
-    );
+    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<Instrument[]> {
-    return this.store.changes$.pipe(
-      filter(it => it instanceof Instrument),
-      map(() => Object.values(this.store.snapshot.universe.instrument)),
-      startWith(Object.values(this.store.snapshot.universe.instrument)),
-      filter(it => it.length > 0),
-      distinctUntilChanged((lhs, rhs) => lhs.length == rhs.length)
-    );
+  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<Trade> {
+  trade(selector: InstrumentSelector): Observable<Readonly<Trade>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(
-        it => it instanceof Trade && it.instrument.toString() == selector.toString()
-      ),
-      map(it => it as Trade)
-    );
+    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<Orderbook> {
+  orderbook(selector: InstrumentSelector): Observable<Readonly<Orderbook>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(
-        it => it instanceof Orderbook && it.instrument.toString() == selector.toString()
-      ),
-      map(it => it as Orderbook)
-    );
+    return this.store.changes$.pipe(orderbook(selector, this.store.snapshot));
   }
 
   /**
    * Subscribes to position on leveraged market.
    */
-  position(selector: InstrumentSelector): Observable<Position> {
+  position(selector: InstrumentSelector): Observable<Readonly<Position>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(
-        it => it instanceof Position && it.instrument.toString() == selector.toString()
-      ),
-      map(it => it as Position)
-    );
+    return this.store.changes$.pipe(position(selector));
   }
 
   /**
    * Subscribes to positions on leveraged markets.
    */
-  positions(selector: InstrumentSelector): Observable<Position[]> {
+  positions(selector: InstrumentSelector): Observable<Readonly<Position[]>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(
-        it => it instanceof Position && it.instrument.toString() == selector.toString()
-      ),
-      map(() =>
-        Object.values(
-          this.store.snapshot.balance[selector.quote.toString()].position
-        ).filter(it => it.instrument.toString() == selector.toString())
-      ),
-      startWith([])
-    );
+    return this.store.changes$.pipe(positions(selector, this.store.snapshot));
   }
 
-  order(selector: InstrumentSelector): Observable<Order> {
+  order(selector: InstrumentSelector): Observable<Readonly<Order>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(
-        it => it instanceof Order && it.instrument.toString() == selector.toString()
-      ),
-      map(it => it as Order)
-    );
+    return this.store.changes$.pipe(order(selector));
   }
 
-  orders(selector: InstrumentSelector, states?: OrderState[]): Observable<Order[]> {
+  orders(selector: InstrumentSelector): Observable<Readonly<Order[]>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(
-        it =>
-          it instanceof Order &&
-          it.instrument.toString() == selector.toString() &&
-          (!states || states.includes(it.state))
-      ),
-      map(() => this.store.snapshot.order),
-      startWith(this.store.snapshot.order),
-      map(it =>
-        Object.values(it)
-          .filter(
-            it =>
-              it.instrument.toString() == selector.toString() &&
-              (states ? states.includes(it.state) : true)
-          )
-          .sort((lhs, rhs) => rhs.createdAt - lhs.createdAt)
-      )
-    );
-  }
-
-  balance(selector: AssetSelector): Observable<Balance> {
-    return this.store.changes$.pipe(
-      startWith(this.store.snapshot.balance[selector.toString()]),
-      filter(
-        it =>
-          it instanceof Balance &&
-          (!selector || it.asset.toString() == selector.toString())
-      ),
-      map(it => it as Balance)
-    );
+    return this.store.changes$.pipe(orders(selector, this.store.snapshot));
   }
 
   history(
     selector: InstrumentSelector,
     timeframe: number,
     length: number
-  ): Observable<Candle> {
+  ): Observable<Readonly<Candle>> {
     return this.store.changes$.pipe(
-      startWith(this.store.snapshot.universe.instrument[selector.toString()]),
-      filter(it => it instanceof Instrument && it.toString() == selector.toString()),
-      switchMap(() =>
-        from(this.aggregate.history({ instrument: selector, timeframe, length }))
-      ),
+      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)

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

@@ -0,0 +1,31 @@
+import { Subject } from 'rxjs';
+
+import { State } from '../store';
+import { Asset } from './asset';
+import { Component } from './component';
+import { Instrument } from './instrument';
+import { Trade } from './trade';
+import { trade } from './trade.operator';
+
+describe('trade', () => {
+  const instrument = new Instrument(
+    new Asset('abc', 'xyz', 4),
+    new Asset('def', 'xyz', 4),
+    'abc-def'
+  );
+
+  const state = new State();
+
+  beforeEach(() => {
+    state.trade.upsert(new Trade(instrument));
+  });
+
+  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();
+      }
+    });
+  });
+});