@quantform/core 0.3.222 → 0.3.230

package/src/session/session-statement.ts

@@ -0,0 +1,119 @@
+import { Session } from '.';
+import { InstrumentSelector } from '../domain';
+import { combineLatest, finalize, map, take, tap } from 'rxjs';
+import { drawdown } from '../indicator';
+import { floor, precision } from '../shared';
+
+export function period() {
+  return (session: Session) => {
+    const period = session.useStatement('period');
+
+    return session.store.changes$.pipe(
+      finalize(() => (period.to = new Date(session.timestamp).toISOString())),
+      take(1),
+      tap(it => (period.from = new Date(it.timestamp).toISOString()))
+    );
+  };
+}
+
+export function benchmark(instrument: InstrumentSelector) {
+  return (session: Session) => {
+    const statement = session.useStatement('benchmark');
+
+    let balance: number, entry: number, exit: number;
+    let dd = 0;
+
+    return combineLatest([
+      session.orderbook(instrument),
+      session.balance(instrument.quote),
+      session.orderbook(instrument).pipe(
+        drawdown(it => it.midRate),
+        tap(it => (dd = it))
+      )
+    ]).pipe(
+      map(([orderbook, quote]) => {
+        const price = orderbook.midRate;
+
+        if (!balance) {
+          balance = quote.total;
+        }
+
+        if (!entry) {
+          entry = price;
+        }
+
+        exit = price;
+      }),
+      finalize(() => {
+        const pnl = exit / entry - 1;
+
+        statement['benchmark_entry'] = entry;
+        statement['benchmark_exit'] = exit;
+        statement['benchmark_pnl'] = floor(balance * pnl, precision(entry));
+        statement['benchmark_pnl_pp'] = floor(pnl * 100, 2);
+        statement['benchmark_drawdown_pp'] = floor(dd * 100, 2);
+      })
+    );
+  };
+}
+
+export function equity(instrument: InstrumentSelector) {
+  return (session: Session) => {
+    const statement = session.useStatement('benchmark');
+
+    let balance: number, min: number, max: number;
+    let dd = 0;
+    let equity = 0;
+
+    return combineLatest([
+      session.orderbook(instrument),
+      session.balance(instrument.base),
+      session.balance(instrument.quote),
+      session.positions(instrument)
+    ]).pipe(
+      tap(([, , quote]) => {
+        if (!balance) {
+          balance = quote.total;
+        }
+      }),
+      map(([orderbook, base, quote, positions]) =>
+        orderbook.instrument.quote.fixed(
+          quote.total +
+            base.total * orderbook.bestBidRate +
+            positions.reduce(
+              (agg, position) => agg + position.calculatePnL(orderbook.bestBidRate),
+              0
+            )
+        )
+      ),
+      tap(it => {
+        if (!min) {
+          min = it;
+        } else {
+          min = Math.min(min, it);
+        }
+
+        if (!max) {
+          max = it;
+        } else {
+          max = Math.max(max, it);
+        }
+
+        equity = it;
+      }),
+      drawdown(it => it),
+      tap(it => (dd = it)),
+      finalize(() => {
+        const pnl = equity / balance - 1;
+        const scale = precision(equity);
+
+        statement['equity'] = equity;
+        statement['equity_min'] = min;
+        statement['equity_max'] = max;
+        statement['equity_pnl'] = floor(balance * pnl, scale);
+        statement['equity_pnl_pp'] = floor(pnl * 100, 2);
+        statement['equity_drawdown_pp'] = floor(dd * 100, 2);
+      })
+    );
+  };
+}

package/src/session/session.spec.ts

@@ -1,8 +1,10 @@
 import { InstrumentPatchEvent } from '../store/event';
-import { Asset, Commision } from '../domain';
-import { now } from '../common';
+import { Asset, Commission } from '../domain';
+import { now } from '../shared';
 import { SessionDescriptor } from './session-descriptor';
 import { paper } from '../bin';
+import { Session } from './session';
+import { of } from 'rxjs';
 
 describe('session tests', () => {
   const descriptor: SessionDescriptor = {
@@ -29,14 +31,14 @@ describe('session tests', () => {
         now(),
         new Asset('de30', 'cex', 2),
         new Asset('usd', 'cex', 2),
-        new Commision(0, 0),
+        new Commission(0, 0),
         ''
       ),
       new InstrumentPatchEvent(
         now(),
         new Asset('wig20', 'cex', 2),
         new Asset('pln', 'cex', 2),
-        new Commision(0, 0),
+        new Commission(0, 0),
         ''
       )
     );

package/src/session/session.ts

@@ -22,9 +22,8 @@ import {
 } from '../domain';
 import { Store } from '../store';
 import { concat, from, Observable, Subject, Subscription } from 'rxjs';
-import { Behaviour, CombinedBehaviour, FunctionBehaviour } from '../behaviour';
 import { AdapterAggregate } from '../adapter/adapter-aggregate';
-import { Worker } from '../common';
+import { Worker, now } from '../shared';
 import { Trade } from '../domain/trade';
 import { SessionDescriptor } from './session-descriptor';
 import {
@@ -39,18 +38,24 @@ type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
 export class Session {
   private initialized = false;
   private subscription: Subscription;
-  private behaviour: Behaviour;
   private worker = new Worker();
 
   get timestamp(): number {
     return this.store.snapshot.timestamp;
   }
 
+  readonly statement: Record<string, Record<string, any>> = {};
+
   constructor(
     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();
+    }
+  }
 
   async awake(): Promise<void> {
     if (this.initialized) {
@@ -59,18 +64,11 @@ export class Session {
 
     this.initialized = true;
 
+    // awake all adapters and synchronize trading accounts with store.
     await this.aggregate.awake(this.descriptor != null);
 
-    if (this.descriptor?.behaviour) {
-      if (this.descriptor.behaviour instanceof Function) {
-        this.behaviour = new FunctionBehaviour(this.descriptor.behaviour);
-      } else {
-        this.behaviour = Array.isArray(this.descriptor.behaviour)
-          ? new CombinedBehaviour(this.descriptor.behaviour)
-          : this.descriptor.behaviour;
-      }
-
-      this.subscription = this.behaviour.describe(this).subscribe();
+    if (this.descriptor.describe) {
+      this.subscription = this.descriptor.describe(this).subscribe();
     }
   }
 
@@ -89,24 +87,29 @@ export class Session {
     await this.worker.wait();
   }
 
-  statement(output: Record<string, any>) {
-    if (!this.behaviour?.statement) {
-      return;
-    }
-
-    this.behaviour.statement(output);
+  useStatement(section: string): Record<string, any> {
+    return this.statement[section] ?? (this.statement[section] = {});
   }
 
+  /**
+   * Returns last stored measurement and setter for it in session.
+   * For example you can save and restore variables in same session between runs.
+   * Example usage:
+   * const [order$, setOrder] = session.measurement<Order>('order');
+   *
+   * order.pipe(tap(it => console.log(`your last order was: ${it}`)));
+   *
+   * setOrder(order);
+   */
   useMeasure<T extends { timestamp: number }>(
-    params: { key: string; timestamp?: number },
+    params: { kind: string; timestamp?: number },
     defaultValue: T = undefined
   ): [Observable<T>, (value: Optional<T, 'timestamp'>) => void] {
     const stored$ = from(
       this.descriptor.measurement.query(this.descriptor.id, {
-        type: params.key,
-        timestamp: params.timestamp ?? this.timestamp,
-        limit: 1,
-        direction: 'BACKWARD'
+        to: params.timestamp ?? this.timestamp,
+        kind: params.kind,
+        count: 1
       })
     ).pipe(
       map(it =>
@@ -119,7 +122,7 @@ export class Session {
 
     const setter = (value: T) => {
       const timestamp = value.timestamp ?? this.timestamp;
-      const measure = { timestamp, type: params.key, payload: value };
+      const measure = { timestamp, kind: params.kind, payload: value };
 
       this.worker.enqueue(() =>
         this.descriptor.measurement.save(this.descriptor.id, [measure])
@@ -131,17 +134,19 @@ export class Session {
     return [concat(stored$, subject$.asObservable()), setter];
   }
 
+  /**
+   * Return values for patch provided in optimization file.
+   * Example usage:
+   * const orderSize = session.useOptimizer('order.size');
+   */
   useOptimizer(path: string): any {
-    const session = this;
-    const [order$, setOrderMeasure] = session.useMeasure(
-      { key: 'ordered' },
-      { limt: 10, timestamp: 0 }
-    );
-
-    setOrderMeasure({ limt: 0, timestamp: 0 });
     return undefined;
   }
 
+  /**
+   * Subscribes to specific instrument. Usually forces adapter to subscribe
+   * for orderbook and ticker streams.
+   */
   async subscribe(instrument: Array<InstrumentSelector>): Promise<void> {
     const grouped = instrument
       .filter(it => it != null)
@@ -162,6 +167,11 @@ export class Session {
     }
   }
 
+  /**
+   * Opens collection of orders.
+   * Example:
+   * session.open(Order.buyMarket(instrument, 100));
+   */
   async open(...orders: Order[]): Promise<void> {
     await Promise.all(
       orders.map(it =>
@@ -173,6 +183,9 @@ export class Session {
     );
   }
 
+  /**
+   * Cancels specific order.
+   */
   cancel(order: Order): Promise<void> {
     return this.aggregate.dispatch(
       order.instrument.base.exchange,
@@ -180,6 +193,10 @@ 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> {
     this.subscribe([selector]);
 
@@ -189,6 +206,10 @@ export class Session {
     );
   }
 
+  /**
+   * 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),
@@ -199,6 +220,9 @@ export class Session {
     );
   }
 
+  /**
+   * Subscribes to trade/ticker changes.
+   */
   trade(selector?: InstrumentSelector): Observable<Trade> {
     this.subscribe([selector]);
 
@@ -212,6 +236,10 @@ export class Session {
     );
   }
 
+  /**
+   * Subscribes to orderbook changes.
+   * Right now you can access only best bid and best ask.
+   */
   orderbook(selector?: InstrumentSelector): Observable<Orderbook> {
     this.subscribe([selector]);
 
@@ -225,6 +253,9 @@ export class Session {
     );
   }
 
+  /**
+   * Subscribes to position on leveraged market.
+   */
   position(selector?: InstrumentSelector): Observable<Position> {
     this.subscribe([selector]);
 
@@ -238,6 +269,9 @@ export class Session {
     );
   }
 
+  /**
+   * Subscribes to positions on leveraged markets.
+   */
   positions(selector: InstrumentSelector): Observable<Position[]> {
     this.subscribe([selector]);
 

package/src/storage/feed.ts

@@ -1,13 +1,38 @@
 import { StoreEvent } from '../store/event';
 import { InstrumentSelector } from '../domain';
-import { timestamp } from '../common';
+import { Storage, StorageQueryOptions } from './storage';
 
-export interface Feed {
-  read(
+export class Feed {
+  constructor(private readonly storage: Storage) {}
+
+  index(): Promise<Array<string>> {
+    return this.storage.index();
+  }
+
+  save(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void> {
+    return this.storage.save(
+      instrument.toString(),
+      events.map(it => ({
+        timestamp: it.timestamp,
+        kind: it.type,
+        json: JSON.stringify(it, (key, value) =>
+          key != 'timestamp' && key != 'type' && key != 'instrument' ? value : undefined
+        )
+      }))
+    );
+  }
+
+  async query(
     instrument: InstrumentSelector,
-    from: timestamp,
-    to: timestamp
-  ): Promise<StoreEvent[]>;
+    options: StorageQueryOptions
+  ): Promise<StoreEvent[]> {
+    const rows = await this.storage.query(instrument.toString(), options);
 
-  write(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void>;
+    return rows.map(it => ({
+      timestamp: it.timestamp,
+      type: it.kind,
+      instrument,
+      ...JSON.parse(it.json)
+    }));
+  }
 }

package/src/storage/index.ts

@@ -1,4 +1,3 @@
 export * from './feed';
-export * from './in-memory.feed';
-export * from './feed.interceptor';
+export * from './storage';
 export * from './measurement';

package/src/storage/measurement.ts

@@ -1,23 +1,37 @@
-import { timestamp } from '../common';
+import { timestamp } from '../shared';
+import { Storage, StorageQueryOptions } from './storage';
 
 export interface Measure {
   timestamp: timestamp;
-  type: string;
+  kind: string;
   payload: any;
 }
 
-export interface Measurement {
-  index(): Promise<Array<number>>;
+export class Measurement {
+  constructor(private readonly storage: Storage) {}
 
-  query(
-    session: number,
-    options: {
-      timestamp: timestamp;
-      type?: string;
-      limit: number;
-      direction: 'FORWARD' | 'BACKWARD';
-    }
-  ): Promise<Measure[]>;
+  async index(): Promise<Array<number>> {
+    return (await this.storage.index()).map(it => Number(it));
+  }
 
-  save(session: number, measurements: Measure[]): Promise<void>;
+  save(session: number, measurements: Measure[]): Promise<void> {
+    return this.storage.save(
+      session.toString(),
+      measurements.map(it => ({
+        timestamp: it.timestamp,
+        kind: it.kind,
+        json: JSON.stringify(it.payload)
+      }))
+    );
+  }
+
+  async query(session: number, options: StorageQueryOptions): Promise<Measure[]> {
+    const rows = await this.storage.query(session.toString(), options);
+
+    return rows.map(it => ({
+      timestamp: it.timestamp,
+      kind: it.kind,
+      payload: JSON.parse(it.json)
+    }));
+  }
 }

package/src/storage/storage.ts

@@ -0,0 +1,76 @@
+export type StorageDocument = {
+  timestamp: number;
+  kind: string;
+  json: string;
+};
+
+export type StorageQueryOptions = {
+  from?: number;
+  to?: number;
+  kind?: string;
+  count: number;
+};
+
+export interface Storage {
+  index(): Promise<Array<string>>;
+
+  save(library: string, documents: StorageDocument[]): Promise<void>;
+
+  query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]>;
+}
+
+export class InMemoryStorage implements Storage {
+  private tables: Record<string, StorageDocument[]> = {};
+
+  async index(): Promise<Array<string>> {
+    return Object.keys(this.tables);
+  }
+
+  async query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]> {
+    if (!this.tables[library]) {
+      return [];
+    }
+
+    let query = this.tables[library];
+
+    if (options.from) {
+      query = query.filter(it => it.timestamp > options.from);
+    }
+
+    if (options.to) {
+      query = query.filter(it => it.timestamp < options.to);
+    }
+
+    if (options.kind) {
+      query = query.filter(it => it.kind == options.kind);
+    }
+
+    if (options.from == undefined && options.to) {
+      query = query.reverse();
+    }
+
+    if (options.count) {
+      query = query.slice(0, options.count);
+    }
+
+    return query;
+  }
+
+  async save(library: string, documents: StorageDocument[]): Promise<void> {
+    if (!this.tables[library]) {
+      this.tables[library] = [];
+    }
+
+    const buffer = this.tables[library];
+
+    for (const document of documents) {
+      buffer.push(document);
+    }
+
+    buffer.sort((lhs, rhs) => lhs.timestamp - rhs.timestamp);
+  }
+
+  clear() {
+    this.tables = {};
+  }
+}

package/src/store/event/store-balance.event.spec.ts

@@ -1,7 +1,7 @@
-import { Asset, Commision } from '../../domain';
+import { Asset, Commission } from '../../domain';
 import { BalancePatchEvent } from '.';
 import { InstrumentPatchEvent } from './store-instrument.event';
-import { now } from '../../common';
+import { now } from '../../shared';
 import { Store } from '..';
 
 describe('balance event tests', () => {
@@ -15,7 +15,7 @@ describe('balance event tests', () => {
     store.changes$.subscribe(it => (component = it));
 
     store.dispatch(
-      new InstrumentPatchEvent(timestamp, base, quote, new Commision(0, 0), '')
+      new InstrumentPatchEvent(timestamp, base, quote, new Commission(0, 0), '')
     );
     store.dispatch(new BalancePatchEvent(base, 100, 0, timestamp));
 

package/src/store/event/store-balance.event.ts

@@ -1,5 +1,5 @@
-import { event } from '../../common/topic';
-import { timestamp } from '../../common';
+import { event } from '../../shared/topic';
+import { timestamp } from '../../shared';
 import { AssetSelector } from '../../domain/asset';
 import { Balance } from '../../domain/balance';
 import { State } from '../store.state';

package/src/store/event/store-candle.event.spec.ts

@@ -0,0 +1,32 @@
+import { Asset, Instrument } from '../../domain';
+import { CandleEvent, CandleEventHandler } from '.';
+import { State } from '../store.state';
+import { now } from '../../shared';
+
+const instrument = new Instrument(
+  new Asset('btc', 'binance', 8),
+  new Asset('usdt', 'binance', 2),
+  'binance:btc-usdt'
+);
+
+describe('candle patch event tests', () => {
+  test('should patch trade object', () => {
+    const timestamp = now();
+    const state = new State();
+
+    state.universe.instrument[instrument.toString()] = instrument;
+    state.subscription.instrument[instrument.toString()] = instrument;
+
+    const event = new CandleEvent(instrument, 1, 1, 1, 1, 1, 1, timestamp);
+
+    CandleEventHandler(event, state);
+
+    const trade = state.trade[instrument.toString()];
+
+    expect(trade.timestamp).toEqual(timestamp);
+    expect(trade.instrument.toString()).toEqual(instrument.toString());
+    expect(trade.rate).toEqual(1);
+    expect(trade.quantity).toEqual(1);
+    expect(state.timestamp).toEqual(timestamp);
+  });
+});

package/src/store/event/store-candle.event.ts

@@ -1,9 +1,12 @@
 import { TradePatchEventHandler } from './store-trade.event';
-import { timestamp } from '../../common/datetime';
+import { OrderbookPatchEventHandler } from './store-orderbook.event';
+import { timestamp } from '../../shared/datetime';
 import { InstrumentSelector } from '../../domain';
 import { State } from '../store.state';
 import { StoreEvent } from './store.event';
+import { event } from '../../shared/topic';
 
+@event
 export class CandleEvent implements StoreEvent {
   type = 'candle';
 
@@ -20,7 +23,10 @@ export class CandleEvent implements StoreEvent {
 }
 
 export function CandleEventHandler(event: CandleEvent, state: State) {
-  return TradePatchEventHandler(
+  const instrument = state.universe.instrument[event.instrument.toString()];
+
+  // patch trade object
+  const trade = TradePatchEventHandler(
     {
       type: 'trade-patch',
       instrument: event.instrument,
@@ -30,4 +36,22 @@ export function CandleEventHandler(event: CandleEvent, state: State) {
     },
     state
   );
+
+  // patch orderbook by assuming candle close price is mid orderbook price
+  const orderbook = OrderbookPatchEventHandler(
+    {
+      type: 'orderbook-patch',
+      instrument: event.instrument,
+      bestAskQuantity: event.volume * 0.5,
+      bestAskRate: event.close + instrument.quote.tickSize,
+      bestBidQuantity: event.volume * 0.5,
+      bestBidRate: event.close - instrument.quote.tickSize,
+      timestamp: event.timestamp
+    },
+    state
+  );
+
+  state.timestamp = event.timestamp;
+
+  return [trade, orderbook];
 }