@quantform/core 0.5.14 → 0.5.15

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,146 +154,84 @@ 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()),
+      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 }))
       ),

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();
+      }
+    });
+  });
+});

package/src/domain/trade.operator.ts

@@ -0,0 +1,15 @@
+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

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

package/src/domain/trade.ts

@@ -7,12 +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;
 
-  constructor(public readonly instrument: Instrument) {}
+  constructor(public readonly instrument: Instrument) {
+    this.id = instrument.id;
+  }
 
   toString() {
     return this.instrument.toString();

package/src/indicator/cross.spec.ts

@@ -2,7 +2,7 @@ import { from } from 'rxjs';
 
 import { crossover, crossunder } from './cross';
 
-describe('crossunder tests', () => {
+describe('crossunder', () => {
   test('should crossunder uptrend once', done => {
     from([1, 2, 3, 4, 5])
       .pipe(
@@ -76,7 +76,7 @@ describe('crossunder tests', () => {
   });
 });
 
-describe('crossover tests', () => {
+describe('crossover', () => {
   test('should crossover downtrend once', done => {
     from([5, 4, 3, 2, 1])
       .pipe(

package/src/indicator/ema.spec.ts

@@ -2,7 +2,7 @@ import { from } from 'rxjs';
 
 import { ema } from './ema';
 
-describe('ema tests', () => {
+describe('ema', () => {
   test('should return expected value', done => {
     let value;
 

package/src/indicator/sma.spec.ts

@@ -2,7 +2,7 @@ import { from } from 'rxjs';
 
 import { sma } from './sma';
 
-describe('sma tests', () => {
+describe('sma', () => {
   test('should return expected value', done => {
     let value;
 

package/src/indicator/tma.spec.ts

@@ -2,7 +2,7 @@ import { from } from 'rxjs';
 
 import { tma } from './tma';
 
-describe('tma tests', () => {
+describe('tma', () => {
   test('should return expected value', done => {
     let value;
 

package/src/indicator/trailing.spec.ts

@@ -2,7 +2,7 @@ import { from } from 'rxjs';
 
 import { trailingdown, trailingup } from './trailing';
 
-describe('trailing up tests', () => {
+describe('trailingup', () => {
   test('should trigger uptrend once', done => {
     let triggered = false;
 
@@ -38,7 +38,7 @@ describe('trailing up tests', () => {
   });
 });
 
-describe('trailingdown tests', () => {
+describe('trailingdown', () => {
   test('should trigger downtrend once', done => {
     let triggered = false;
 

package/src/indicator/truerange.spec.ts

@@ -5,7 +5,7 @@ import { now } from '../shared';
 import { sma } from './sma';
 import { truerange } from './truerange';
 
-describe('truerange atr tests', () => {
+describe('truerange', () => {
   test('should return expected value', done => {
     let value;
 

package/src/indicator/wma.spec.ts

@@ -2,7 +2,7 @@ import { from } from 'rxjs';
 
 import { wma } from './wma';
 
-describe('wma tests', () => {
+describe('wma', () => {
   test('should return expected value', done => {
     let value;
     //12 Dec 2020 00:00

package/src/shared/collections.ts

@@ -0,0 +1,35 @@
+export class Set<T extends { id: string }> {
+  private readonly array: Array<T> = [];
+
+  constructor(values?: ReadonlyArray<T>) {
+    if (values) {
+      values.forEach(it => this.upsert(it));
+    }
+  }
+
+  get(id: string) {
+    return this.array.find(it => it.id == id);
+  }
+
+  tryGetOrSet(id: string, setter: () => T): T {
+    return this.get(id) ?? this.upsert(setter());
+  }
+
+  upsert(value: T) {
+    this.array.forEach((it, idx) => {
+      if (it.id == value.id) {
+        this.array[idx] = value;
+
+        return value;
+      }
+    });
+
+    this.array.push(value);
+
+    return value;
+  }
+
+  asReadonlyArray(): ReadonlyArray<T> {
+    return this.array;
+  }
+}

package/src/shared/datetime.ts

@@ -3,15 +3,3 @@ export type timestamp = number;
 export function now(): timestamp {
   return new Date().getTime();
 }
-
-export function toString(timestamp: timestamp): string {
-  const date = new Date(timestamp);
-  const day = ('0' + date.getDate()).slice(-2);
-  const month = ('0' + (date.getMonth() + 1)).slice(-2);
-  const year = date.getFullYear();
-  const hours = ('0' + date.getHours()).slice(-2);
-  const minutes = ('0' + date.getMinutes()).slice(-2);
-  const seconds = ('0' + date.getSeconds()).slice(-2);
-
-  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
-}

package/src/shared/decimals.spec.ts

@@ -1,6 +1,6 @@
 import { ceil, fixed, floor, precision } from './decimals';
 
-describe('decimals tests', () => {
+describe('decimals', () => {
   test('get precision tests', () => {
     expect(precision(0.01)).toEqual(2);
     expect(precision(0.0054)).toEqual(4);
@@ -14,6 +14,7 @@ describe('decimals tests', () => {
     expect(fixed(0.011, 2)).toEqual(0.01);
     expect(fixed(0.019, 2)).toEqual(0.01);
     expect(fixed(0.019, 0)).toEqual(0);
+    expect(fixed(0.00000058, 8)).toEqual(0.00000058);
   });
 
   test('floor tests', () => {

package/src/shared/decimals.ts

@@ -50,7 +50,10 @@ export function ceil(number: number, precision: number): number {
  * @returns rounded number
  */
 export function fixed(number: number, precision: number): number {
-  return floor(number, precision);
+  return (
+    Math.floor((number + Number.EPSILON) * Math.pow(10, precision)) /
+    Math.pow(10, precision)
+  );
 }
 
 export function weightedMean(values: number[], weights: number[]) {
@@ -69,11 +72,8 @@ export function weightedMean(values: number[], weights: number[]) {
   return result[0] / result[1];
 }
 
-export function pnl(entryRate: number, exitRate: number, size: number) {
-  const cost = size * entryRate;
-  const unrealized = size * exitRate;
-
-  return unrealized - cost;
+export function pnl(entryRate: number, exitRate: number, amount: number) {
+  return (exitRate / entryRate - 1) * amount;
 }
 
 /**

package/src/shared/index.ts

@@ -3,4 +3,4 @@ export * from './decimals';
 export * from './io';
 export * from './logger';
 export * from './policy';
-export * from './topic';
+export * from './collections';

package/src/shared/io.ts

@@ -1,5 +1,3 @@
-import fs = require('fs');
-
 export function workingDirectory() {
   return './.quantform/';
 }

package/src/shared/policy.ts

@@ -1,18 +1,5 @@
-import * as hash from 'object-hash';
 import { retryAsync } from 'ts-retry';
 
 export function retry<T>(fn: () => Promise<T>): Promise<T> {
   return retryAsync(fn, { delay: 1000, maxTry: 3 });
 }
-
-const inMemoryCache: Record<string, any> = {};
-
-export async function cache<T>(key: any, fn: () => Promise<T>): Promise<T> {
-  const hashed = hash(key);
-
-  if (inMemoryCache[hashed]) {
-    return inMemoryCache[hashed];
-  }
-
-  return (inMemoryCache[hashed] = await fn());
-}

package/src/storage/cache.spec.ts

@@ -0,0 +1,18 @@
+import { Cache } from './cache';
+import { InMemoryStorage } from './storage';
+
+describe('Cache', () => {
+  test('should return cached value', async () => {
+    const cache = new Cache(new InMemoryStorage());
+
+    const value1 = await cache.tryGet(() => Promise.resolve('quantform-1'), {
+      key: 'test'
+    });
+    const value2 = await cache.tryGet(() => Promise.resolve('quantform-2'), {
+      key: 'test'
+    });
+
+    expect(value1).toEqual('quantform-1');
+    expect(value2).toEqual('quantform-1');
+  });
+});

package/src/storage/cache.ts

@@ -13,7 +13,7 @@ export class Cache {
     const payload = await this.storage.query(options.key, {
       kind: 'cache',
       count: 1,
-      to: time
+      to: time + 1
     });
 
     if ((!payload.length || payload[0].timestamp < time - options.ttl) ?? 60 * 60 * 24) {