@quantform/core 0.3.264 → 0.3.272

package/src/adapter/index.ts

@@ -1,2 +1,4 @@
 export * from './adapter';
 export * from './adapter-aggregate';
+export * from './backtester';
+export * from './paper';

package/src/adapter/paper/index.ts

@@ -1,3 +1,3 @@
 export * from './paper-adapter';
-export * from './executor/paper-spot-executor';
-export * from './executor/paper-margin-executor';
+export * from './simulator/paper-margin-simulator';
+export * from './simulator/paper-spot-simulator';

package/src/adapter/paper/paper-adapter.spec.ts

@@ -1,12 +1,10 @@
-import { PaperSpotExecutor } from '.';
+import { PaperSpotSimulator } from '.';
 import { AdapterContext } from '..';
-import { Store } from '../../store';
+import { InstrumentPatchEvent, Store } from '../../store';
 import { Adapter } from '../adapter';
-import { PaperExecutor } from './executor/paper-executor';
+import { Asset, Commission, instrumentOf, Order } from './../../domain';
 import { PaperAdapter } from './paper-adapter';
-import { Order, Asset, Commission, assetOf } from './../../domain';
-import { instrumentOf } from './../../domain/instrument';
-import { BalancePatchEvent, InstrumentPatchEvent } from '../../store/event';
+import { PaperSimulator } from './simulator/paper-simulator';
 
 class DefaultAdapter extends Adapter {
   name = 'default';
@@ -29,8 +27,8 @@ class DefaultAdapter extends Adapter {
     );
   }
 
-  createPaperExecutor(adapter: PaperAdapter): PaperExecutor {
-    return new PaperSpotExecutor(adapter);
+  createPaperSimulator(adapter: PaperAdapter): PaperSimulator {
+    return new PaperSpotSimulator(adapter);
   }
 }
 

package/src/adapter/paper/paper-adapter.ts

@@ -1,18 +1,16 @@
 import { Adapter, AdapterContext } from '..';
-import { Store } from '../../store';
-import { PaperExecutor } from './executor/paper-executor';
 import { assetOf, Candle, InstrumentSelector, Order } from '../../domain';
-import { BalancePatchEvent } from '../../store/event';
-import { Feed } from 'src/storage';
+import { BalancePatchEvent, Store } from '../../store';
 import { FeedQuery, HistoryQuery } from '../adapter';
+import { PaperSimulator } from './simulator/paper-simulator';
 
-export class PaperOptions {
+export interface PaperOptions {
   balance: { [key: string]: number };
 }
 
 export class PaperAdapter extends Adapter {
   readonly name = this.decoratedAdapter.name;
-  readonly executor: PaperExecutor;
+  readonly simulator: PaperSimulator;
 
   constructor(
     readonly decoratedAdapter: Adapter,
@@ -21,7 +19,7 @@ export class PaperAdapter extends Adapter {
   ) {
     super();
 
-    this.executor = this.createPaperExecutor(this);
+    this.simulator = this.createPaperSimulator(this);
   }
 
   timestamp() {
@@ -68,11 +66,11 @@ export class PaperAdapter extends Adapter {
   }
 
   async open(order: Order): Promise<void> {
-    this.executor.open(order);
+    this.simulator.open(order);
   }
 
   async cancel(order: Order): Promise<void> {
-    this.executor.cancel(order);
+    this.simulator.cancel(order);
   }
 
   history(query: HistoryQuery): Promise<Candle[]> {
@@ -83,7 +81,7 @@ export class PaperAdapter extends Adapter {
     return this.decoratedAdapter.feed(query);
   }
 
-  createPaperExecutor(adapter: PaperAdapter): PaperExecutor {
-    return this.decoratedAdapter.createPaperExecutor(adapter);
+  createPaperSimulator(adapter: PaperAdapter): PaperSimulator {
+    return this.decoratedAdapter.createPaperSimulator(adapter);
   }
 }

package/src/adapter/paper/{executor/paper-margin-executor.ts → simulator/paper-margin-simulator.ts}

@@ -1,5 +1,6 @@
-import { pnl, weightedMean } from '../../../shared';
+import { PaperAdapter } from '..';
 import { Order } from '../../../domain';
+import { pnl, weightedMean } from '../../../shared';
 import {
   BalanceTransactEvent,
   OrderCanceledEvent,
@@ -8,11 +9,10 @@ import {
   OrderNewEvent,
   OrderPendingEvent,
   PositionPatchEvent
-} from '../../../store/event';
-import { PaperAdapter } from '..';
-import { PaperExecutor } from './paper-executor';
+} from '../../../store';
+import { PaperSimulator } from './paper-simulator';
 
-export class PaperMarginExecutor extends PaperExecutor {
+export class PaperMarginSimulator extends PaperSimulator {
   leverage = 10;
 
   constructor(adapter: PaperAdapter) {

package/src/adapter/paper/{executor/paper-executor.ts → simulator/paper-simulator.ts}

@@ -1,9 +1,9 @@
-import { tap } from 'rxjs/operators';
-import { Component, InstrumentSelector, Order, Orderbook, Trade } from '../../../domain';
-import { PaperAdapter } from '..';
+import { tap } from 'rxjs';
 import { Set } from 'typescript-collections';
+import { PaperAdapter } from '..';
+import { Component, InstrumentSelector, Order, Orderbook, Trade } from '../../../domain';
 
-export abstract class PaperExecutor {
+export abstract class PaperSimulator {
   private readonly pending: Record<string, Set<Order>> = {};
 
   constructor(readonly adapter: PaperAdapter) {

package/src/adapter/paper/simulator/paper-spot-simulator.spec.ts

@@ -0,0 +1,87 @@
+import { PaperAdapter } from '../paper-adapter';
+import {
+  Asset,
+  assetOf,
+  Commission,
+  commissionPercentOf,
+  instrumentOf,
+  Order
+} from './../../../domain';
+import {
+  BalancePatchEvent,
+  InstrumentPatchEvent,
+  InstrumentSubscriptionEvent,
+  Store,
+  TradePatchEvent
+} from './../../../store';
+import { Adapter, AdapterContext } from './../../adapter';
+import { PaperSimulator } from './paper-simulator';
+import { PaperSpotSimulator } from './paper-spot-simulator';
+
+class DefaultAdapter extends Adapter {
+  name = 'default';
+
+  timestamp() {
+    return 123;
+  }
+
+  async awake(context: AdapterContext): Promise<void> {
+    await super.awake(context);
+
+    context.dispatch(
+      new InstrumentPatchEvent(
+        context.timestamp,
+        new Asset('a', this.name, 8),
+        new Asset('b', this.name, 4),
+        new Commission(0.1, 0.1),
+        'a-b'
+      )
+    );
+  }
+
+  createPaperSimulator(adapter: PaperAdapter): PaperSimulator {
+    return new PaperSpotSimulator(adapter);
+  }
+}
+
+describe('paper spot simulator tests', () => {
+  const options = {
+    balance: {
+      ['default:a']: 1000,
+      ['default:b']: 200
+    }
+  };
+
+  test('should open an market order', async () => {
+    const store = new Store();
+    const adapter = new DefaultAdapter();
+    const order = Order.buyMarket(instrumentOf('default:a-b'), 1);
+
+    store.dispatch(
+      new InstrumentPatchEvent(
+        0,
+        new Asset('a', 'default', 8),
+        new Asset('b', 'default', 4),
+        commissionPercentOf(0.1, 0.1),
+        'a-b'
+      ),
+      new BalancePatchEvent(assetOf('default:a'), 1000, 0, 1)
+    );
+    store.dispatch(new BalancePatchEvent(assetOf('default:b'), 1000, 0, 1));
+    store.dispatch(new InstrumentSubscriptionEvent(1, instrumentOf('default:a-b'), true));
+
+    const sut = new PaperSpotSimulator(new PaperAdapter(adapter, store, options));
+
+    await sut.open(order);
+
+    expect(store.snapshot.order[order.id].state).toBe('PENDING');
+
+    store.dispatch(new TradePatchEvent(instrumentOf('default:a-b'), 5, 1, 2));
+
+    expect(store.snapshot.order[order.id].quantity).toBe(1);
+    expect(store.snapshot.order[order.id].averageExecutionRate).toBe(5);
+    expect(store.snapshot.order[order.id].state).toBe('FILLED');
+    expect(store.snapshot.balance['default:b'].free).toBe(995);
+    expect(store.snapshot.balance['default:a'].free).toBe(1000.999);
+  });
+});

package/src/adapter/paper/{executor/paper-spot-executor.ts → simulator/paper-spot-simulator.ts}

@@ -1,4 +1,6 @@
-import { Order, Orderbook } from '../../../domain';
+import { PaperAdapter } from '..';
+import { Order } from '../../../domain';
+import { timestamp } from '../../../shared';
 import {
   BalanceFreezEvent,
   BalanceTransactEvent,
@@ -8,12 +10,10 @@ import {
   OrderFilledEvent,
   OrderNewEvent,
   OrderPendingEvent
-} from '../../../store/event';
-import { PaperAdapter } from '..';
-import { PaperExecutor } from './paper-executor';
-import { timestamp } from '../../../shared';
+} from '../../../store';
+import { PaperSimulator } from './paper-simulator';
 
-export class PaperSpotExecutor extends PaperExecutor {
+export class PaperSpotSimulator extends PaperSimulator {
   constructor(readonly adapter: PaperAdapter) {
     super(adapter);
   }

package/src/bootstrap.ts

@@ -1,10 +1,10 @@
 import {
+  AdapterAggregate,
   BacktesterAdapter,
   BacktesterListener,
-  BacktesterStreamer
-} from './adapter/backtester';
-import { AdapterAggregate } from './adapter';
-import { PaperAdapter } from './adapter/paper';
+  BacktesterStreamer,
+  PaperAdapter
+} from './adapter';
 import { Session, SessionDescriptor } from './domain';
 import { Store } from './store';
 

package/src/domain/balance.ts

@@ -1,7 +1,7 @@
 import { timestamp } from '../shared';
 import { Asset } from './';
-import { Position, PositionMode } from './position';
 import { Component } from './component';
+import { Position, PositionMode } from './position';
 
 /**
  * Represents single asset balance in your wallet.

package/src/domain/candle.spec.ts

@@ -1,9 +1,7 @@
-import { from } from 'rxjs';
-import { map } from 'rxjs/operators';
-import { TradePatchEvent } from '../store/event';
+import { from, map } from 'rxjs';
 import { now } from '../shared';
-import { Candle } from './candle';
-import { mergeCandle } from './candle-builder';
+import { TradePatchEvent } from '../store';
+import { Candle, mergeCandle } from './candle';
 import { instrumentOf } from './instrument';
 import { Timeframe } from './timeframe';
 

package/src/domain/candle.ts

@@ -1,4 +1,16 @@
+import {
+  concat,
+  filter,
+  last,
+  map,
+  mergeMap,
+  Observable,
+  share,
+  skipLast,
+  withLatestFrom
+} from 'rxjs';
 import { timestamp } from '../shared';
+import { tf } from './timeframe';
 
 export class Candle {
   constructor(
@@ -15,3 +27,94 @@ export class Candle {
     this.close = value;
   }
 }
+
+export class CandleBuilder {
+  private _candle: Candle;
+
+  get candle(): Candle {
+    return this._candle;
+  }
+
+  constructor(readonly timeframe: number) {}
+
+  append(value: number, timestamp: timestamp): Candle {
+    const frame = tf(timestamp, this.timeframe);
+
+    if (!this._candle) {
+      this._candle = new Candle(frame, value, value, value, value);
+
+      return null;
+    }
+
+    if (this.candle.timestamp == frame) {
+      this.candle.apply(value);
+
+      return null;
+    }
+
+    const previous = this._candle;
+
+    this._candle = new Candle(frame, value, value, value, value);
+    return previous;
+  }
+}
+
+export function candle<T extends { timestamp: number }>(
+  timeframe: number,
+  fn: (x: T) => number
+) {
+  return function (source: Observable<T>): Observable<Candle> {
+    const builder = new CandleBuilder(timeframe);
+    let candle: Candle;
+
+    return source.pipe(
+      filter(it => {
+        return (candle = builder.append(fn(it), it.timestamp)) != null;
+      }),
+      map(_ => candle),
+      share()
+    );
+  };
+}
+
+export function mergeCandle<T extends { timestamp: number }>(
+  timeframe: number,
+  fn: (x: T) => number,
+  history$: Observable<Candle>
+) {
+  return function (source$: Observable<T>): Observable<Candle> {
+    const builder = new CandleBuilder(timeframe);
+    let hasMergedHistory = false;
+
+    return concat(
+      history$.pipe(skipLast(1)),
+      source$.pipe(
+        withLatestFrom(history$.pipe(last())),
+        mergeMap(([it, history]) => {
+          const completed = builder.append(fn(it), it.timestamp);
+
+          if (completed) {
+            if (completed.timestamp == history.timestamp) {
+              completed.open = history.open;
+              completed.high = Math.max(completed.high, history.high);
+              completed.low = Math.min(completed.low, history.low);
+
+              hasMergedHistory = true;
+            } else if (completed.timestamp > history.timestamp) {
+              if (!hasMergedHistory) {
+                hasMergedHistory = true;
+                return [history, completed];
+              }
+            } else if (completed.timestamp < history.timestamp) {
+              throw new Error('invalid candle sequence, input data is to old.');
+            }
+
+            return [completed];
+          }
+
+          return [];
+        })
+      )
+    );
+  };
+}

package/src/domain/index.ts

@@ -1,15 +1,13 @@
 export * from './asset';
-export * from './instrument';
 export * from './balance';
-export * from './order';
-export * from './orderbook';
+export * from './candle';
 export * from './commission';
 export * from './component';
-export * from './candle';
-export * from './candle-builder';
-export * from './timeframe';
+export * from './instrument';
+export * from './order';
+export * from './orderbook';
 export * from './position';
-export * from './trade';
 export * from './session';
-export * from './session-descriptor';
 export * from './statement';
+export * from './timeframe';
+export * from './trade';

package/src/domain/order.ts

@@ -1,7 +1,7 @@
-import { Component } from './component';
 import { v4 } from 'uuid';
-import { InstrumentSelector } from './instrument';
 import { timestamp } from '../shared';
+import { Component } from './component';
+import { InstrumentSelector } from './instrument';
 
 export type OrderSide = 'SELL' | 'BUY';
 export type OrderType = 'MARKET' | 'LIMIT' | 'STOP-MARKET' | 'STOP-LIMIT';

package/src/domain/orderbook.ts

@@ -1,5 +1,5 @@
-import { timestamp } from '../shared';
 import { Instrument } from '../domain';
+import { timestamp } from '../shared';
 import { Component } from './component';
 
 /**

package/src/domain/position.ts

@@ -1,8 +1,7 @@
+import { map, Observable, share } from 'rxjs';
 import { Instrument } from '../domain';
-import { Component } from './component';
 import { pnl, timestamp, weightedMean } from '../shared';
-import { Observable } from 'rxjs';
-import { map, share } from 'rxjs/operators';
+import { Component } from './component';
 
 export type PositionMode = 'CROSS' | 'ISOLATED';
 

package/src/domain/session.spec.ts

@@ -1,8 +1,8 @@
-import { InstrumentPatchEvent } from '../store/event';
+import { Bootstrap } from '../bootstrap';
 import { Asset, Commission } from '../domain';
 import { now } from '../shared';
-import { SessionDescriptor } from './session-descriptor';
-import { Bootstrap } from '../bootstrap';
+import { InstrumentPatchEvent } from '../store';
+import { SessionDescriptor } from './session';
 
 describe('session tests', () => {
   const descriptor: SessionDescriptor = {

package/src/domain/session.ts

@@ -1,14 +1,21 @@
 import {
+  concat,
   distinctUntilChanged,
   filter,
+  from,
   map,
   mergeMap,
+  Observable,
   share,
   shareReplay,
   startWith,
+  Subject,
+  Subscription,
   switchMap,
   take
-} from 'rxjs/operators';
+} from 'rxjs';
+import { Adapter, BacktesterOptions, PaperOptions } from '../adapter';
+import { AdapterAggregate } from '../adapter/adapter-aggregate';
 import {
   AssetSelector,
   Balance,
@@ -16,19 +23,65 @@ import {
   Instrument,
   InstrumentSelector,
   Order,
-  Position,
   Orderbook,
-  OrderState
+  OrderState,
+  Position
 } from '../domain';
-import { Store } from '../store';
-import { concat, from, Observable, Subject, Subscription } from 'rxjs';
-import { AdapterAggregate } from '../adapter/adapter-aggregate';
-import { Worker, now } from '../shared';
 import { Trade } from '../domain/trade';
-import { SessionDescriptor } from './session-descriptor';
+import { now, Worker } from '../shared';
+import { Feed, Measurement } from '../storage';
+import { Store } from '../store';
 
 type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
 
+/**
+ * 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 {
+  /**
+   * 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: Adapter[];
+
+  /**
+   * Provides historical data for backtest, it's not required for live and paper
+   * sessions.
+   */
+  feed?: Feed;
+
+  /**
+   * 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.
+   */
+  measurement?: Measurement;
+
+  /**
+   * Session additional options.
+   */
+  options?: {
+    backtester?: BacktesterOptions;
+    paper?: PaperOptions;
+  };
+}
+
 export class Session {
   private initialized = false;
   private subscription: Subscription;

package/src/domain/statement.ts

@@ -1,6 +1,5 @@
-import { Session } from '.';
-import { InstrumentSelector } from '.';
 import { combineLatest, finalize, map, take, tap } from 'rxjs';
+import { InstrumentSelector, Session } from '.';
 import { drawdown } from '../indicator';
 import { floor, precision } from '../shared';
 

package/src/domain/trade.ts

@@ -1,5 +1,5 @@
-import { timestamp } from '../shared';
 import { Instrument } from '.';
+import { timestamp } from '../shared';
 import { Component } from './component';
 
 /**

package/src/index.ts

@@ -1,11 +1,8 @@
-export * from './shared';
-export * from './domain';
 export * from './adapter';
-export * from './adapter/backtester';
-export * from './adapter/paper';
+export * from './bootstrap';
+export * from './domain';
 export * from './indicator';
+export * from './ipc';
+export * from './shared';
 export * from './storage';
 export * from './store';
-export * from './store/event';
-export * from './bootstrap';
-export * from './ipc';

package/src/indicator/atr.ts

@@ -1,5 +1,4 @@
-import { Observable } from 'rxjs';
-import { share, map } from 'rxjs/operators';
+import { map, Observable, share } from 'rxjs';
 import { Candle } from '../domain';
 import { rma } from './rma';
 import { truerange } from './truerange';

package/src/indicator/cross.ts

@@ -1,8 +1,7 @@
-import { Observable } from 'rxjs';
-import { filter } from 'rxjs/operators';
+import { filter, Observable } from 'rxjs';
 
 export function crossunder<T>(limitFn: (it: T) => number, currentFn: (it: T) => number) {
-  return function(source: Observable<T>): Observable<T> {
+  return function (source: Observable<T>): Observable<T> {
     let triggered = false;
 
     return source.pipe(
@@ -27,7 +26,7 @@ export function crossunder<T>(limitFn: (it: T) => number, currentFn: (it: T) =>
 }
 
 export function crossover<T>(limitFn: (it: T) => number, currentFn: (it: T) => number) {
-  return function(source: Observable<T>): Observable<T> {
+  return function (source: Observable<T>): Observable<T> {
     let triggered = false;
 
     return source.pipe(

package/src/indicator/donchian.ts

@@ -1,7 +1,6 @@
-import { Observable, withLatestFrom } from 'rxjs';
-import { map, share } from 'rxjs/operators';
-import { minMax } from './min-max';
+import { map, Observable, share, withLatestFrom } from 'rxjs';
 import { Candle } from '../domain';
+import { minMax } from './min-max';
 
 export function donchian<T>(length: number, fn: (it: T) => Candle) {
   return function (source: Observable<T>): Observable<

package/src/indicator/drawdown.ts

@@ -1,8 +1,7 @@
-import { Observable } from 'rxjs';
-import { map, share } from 'rxjs/operators';
+import { map, Observable, share } from 'rxjs';
 
 export function drawdown<T>(fn: (it: T) => number) {
-  return function(source: Observable<T>): Observable<number> {
+  return function (source: Observable<T>): Observable<number> {
     let rate;
     let max = 0;
 

package/src/indicator/ema.ts

@@ -1,5 +1,4 @@
-import { Observable } from 'rxjs';
-import { map, share } from 'rxjs/operators';
+import { map, Observable, share } from 'rxjs';
 import { sma } from './sma';
 
 export function ema<T>(length: number, fn: (it: T) => number) {

package/src/indicator/envelope.ts

@@ -1,5 +1,4 @@
-import { Observable } from 'rxjs';
-import { map, share } from 'rxjs/operators';
+import { map, Observable, share } from 'rxjs';
 import { sma } from './sma';
 
 export function envelope<T>(length: number, percent: number, valueFn: (it: T) => number) {