@quantform/core 0.5.23 → 0.6.4

package/src/cli/test.ts

@@ -1,53 +1,40 @@
-import { Bootstrap } from '../bootstrap';
+import { join } from 'path';
+
+import { SessionBuilder } from '../domain/session-builder';
+import { Logger, now } from '../shared';
+import { prepare } from '../strategy';
 import build from './build';
-import { getModule } from './internal/workspace';
+import { buildDirectory } from './internal/workspace';
 
-export default async function (name, options: any) {
+export default async function (name: string, options: any) {
   if (await build()) {
     return;
   }
 
-  const module = await getModule(name);
+  await import(join(buildDirectory(), 'index'));
 
-  const bootstrap = new Bootstrap(module.descriptor);
+  const builder = new SessionBuilder().useSessionId(
+    options.id ? Number(options.id) : now()
+  );
 
-  if (!module.descriptor.storage) {
-    throw new Error('Please provide a "storage" property in session descriptor.');
-  }
+  const rules = await prepare(name, builder);
 
-  const from = options.from
-    ? Date.parse(options.from)
-    : module.descriptor.simulation.from;
+  const startTime = performance.now();
 
-  if (!from) {
-    throw new Error(
-      'Please set a "from" date in session descriptor or provide the date as parameter.'
-    );
-  }
+  const [session, backtester] = builder.backtest({
+    onBacktestStarted: () => Logger.info('backtest', `new session ${session.id} started`),
+    onBacktestCompleted: async () => {
+      await session.dispose();
 
-  const to = options.to ? Date.parse(options.to) : module.descriptor.simulation.to;
+      const seconds = ((performance.now() - startTime) / 1000).toFixed(3);
 
-  if (!to) {
-    throw new Error(
-      'Please set a "to" date in session descriptor or provide the date as parameter.'
-    );
-  }
-
-  await new Promise<void>(async resolve => {
-    const [session] = bootstrap.useBacktestPeriod(from, to).backtest({
-      onBacktestStarted: () => {
-        console.log('backtest started');
-        console.time('backtest completed');
-      },
-      onBacktestCompleted: async () => {
-        await session.dispose();
+      Logger.info('backtest', `session ${session.id} completed in ${seconds}s`);
+    }
+  });
 
-        console.timeEnd('backtest completed');
+  await session.awake();
 
-        resolve();
-      }
-    });
+  rules(session).subscribe();
 
-    await session.awake(module.default);
-  });
+  backtester.tryContinue();
 }

package/src/domain/asset.ts

@@ -4,7 +4,7 @@ import { invalidArgumentError, invalidAssetSelectorError } from './error';
 export const AssetSelectorSeparator = ':';
 
 /**
- * Supposed to query specific @see Asset from based on string notation.
+ * Supposed to query specific @see Asset based on string notation.
  */
 export class AssetSelector {
   readonly id: string;

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

@@ -3,18 +3,19 @@ import { Subject } from 'rxjs';
 import { State } from '../store';
 import { Asset } from './asset';
 import { Balance } from './balance';
-import { balance } from './balance.operator';
+import { balance } from './balance-operator';
 import { Component } from './component';
 
 describe('balance', () => {
+  const timestamp = 0;
   const asset = new Asset('abc', 'xyz', 4);
   const state = new State();
 
   beforeEach(() => {
-    state.balance.upsert(new Balance(asset));
+    state.balance.upsert(new Balance(timestamp, asset));
   });
 
-  test('should pipe a balance on subscription', done => {
+  test('should pipe a balance snapshot when subscribed', done => {
     new Subject<Component>().pipe(balance(asset, state)).subscribe({
       next: it => {
         expect(it.asset).toEqual(asset);

package/src/domain/balance.spec.ts

@@ -1,19 +1,22 @@
 import { d } from '../shared';
 import { Asset } from './asset';
 import { Balance } from './balance';
+import { Commission } from './commission';
 import { Instrument } from './instrument';
 import { Position } from './position';
 
 describe('Balance', () => {
   const asset = new Asset('abc', 'xyz', 4);
   const instrument = new Instrument(
+    0,
     new Asset('abc', 'xyz', 4),
     new Asset('def', 'xyz', 4),
-    'abc-def'
+    'abc-def',
+    Commission.Zero
   );
 
   test('should construct empty balance', () => {
-    const sut = new Balance(asset);
+    const sut = new Balance(0, asset);
 
     expect(sut.asset.id).toEqual('xyz:abc');
     expect(sut.free).toEqual(d.Zero);
@@ -22,7 +25,7 @@ describe('Balance', () => {
   });
 
   test('should construct balance', () => {
-    const sut = new Balance(asset);
+    const sut = new Balance(1, asset);
 
     sut.set(d(100), d(50));
 
@@ -34,7 +37,7 @@ describe('Balance', () => {
   });
 
   test('should account positive amount', () => {
-    const sut = new Balance(asset);
+    const sut = new Balance(0, asset);
 
     sut.set(d(100), d.Zero);
     sut.account(d(10));
@@ -45,7 +48,7 @@ describe('Balance', () => {
   });
 
   test('should account negative amount', () => {
-    const sut = new Balance(asset);
+    const sut = new Balance(0, asset);
 
     sut.set(d(100), d.Zero);
     sut.account(d(-10));
@@ -56,7 +59,7 @@ describe('Balance', () => {
   });
 
   test('should throw for insufficient balance account amount', () => {
-    const sut = new Balance(asset);
+    const sut = new Balance(0, asset);
 
     sut.set(d(100), d.Zero);
     const fn = () => sut.account(d(-120));
@@ -65,7 +68,7 @@ describe('Balance', () => {
   });
 
   test('should lock specific amount of available balance', () => {
-    const sut = new Balance(asset);
+    const sut = new Balance(0, asset);
 
     sut.set(d(100), d.Zero);
     sut.lock('key', d(10));
@@ -76,7 +79,7 @@ describe('Balance', () => {
   });
 
   test('should throw for lock insufficient amount of available balance', () => {
-    const sut = new Balance(asset);
+    const sut = new Balance(0, asset);
 
     sut.set(d(30), d(50));
     const fn = () => sut.lock('key', d(100));
@@ -84,8 +87,8 @@ describe('Balance', () => {
     expect(fn).toThrowError();
   });
 
-  test('should lock an unlock specific amount of available balance', () => {
-    const sut = new Balance(asset);
+  test('should lock and unlock specific amount of available balance', () => {
+    const sut = new Balance(0, asset);
 
     sut.set(d(100), d.Zero);
     sut.lock('key', d(40));
@@ -97,11 +100,11 @@ describe('Balance', () => {
   });
 
   test('should return correct estimated unrealized pnl', () => {
-    const position = new Position('1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
+    const position = new Position(0, '1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
 
     position.calculateEstimatedUnrealizedPnL(d(2576.44));
 
-    const sut = new Balance(asset);
+    const sut = new Balance(0, asset);
 
     sut.set(d(100), d.Zero);
     sut.position['1'] = position;

package/src/domain/balance.ts

@@ -1,4 +1,4 @@
-import { d, decimal, timestamp } from '../shared';
+import { d, decimal } from '../shared';
 import { Asset } from './';
 import { Component } from './component';
 import { insufficientFundsError, invalidArgumentError } from './error';
@@ -10,7 +10,6 @@ import { Position, PositionMode } from './position';
 export class Balance implements Component {
   id: string;
   kind = 'balance';
-  timestamp: timestamp;
 
   private locker: Record<string, decimal> = {};
   private available = d.Zero;
@@ -45,7 +44,7 @@ export class Balance implements Component {
    */
   readonly position: Record<string, Position> = {};
 
-  constructor(public readonly asset: Asset) {
+  constructor(public timestamp: number, public readonly asset: Asset) {
     this.id = asset.id;
   }
 
@@ -106,9 +105,11 @@ export class Balance implements Component {
   getEstimatedUnrealizedPnL(mode?: PositionMode): decimal {
     return Object.values(this.position).reduce(
       (aggregate, position) =>
-        (aggregate = aggregate.add(
-          mode && mode != position.mode ? 0 : position.estimatedUnrealizedPnL
-        )),
+        aggregate.add(
+          mode && mode != position.mode
+            ? d.Zero
+            : position.estimatedUnrealizedPnL ?? d.Zero
+        ),
       d.Zero
     );
   }

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

@@ -2,7 +2,7 @@ import { from } from 'rxjs';
 
 import { d } from '../shared';
 import { Candle } from './candle';
-import { candle, candleCompleted, mergeCandle } from './candle.operator';
+import { candle, candleCompleted, mergeCandle } from './candle-operator';
 
 describe('candle', () => {
   test('should aggregate and pipe candle updates', done => {

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

@@ -5,6 +5,7 @@ import {
   map,
   mergeMap,
   Observable,
+  OperatorFunction,
   share,
   skipLast,
   switchMap
@@ -14,7 +15,12 @@ import { decimal } from '../shared';
 import { Candle } from './candle';
 import { tf } from './timeframe';
 
-function aggregate(candle: Candle, timeframe: number, value: decimal, timestamp: number) {
+function aggregate(
+  candle: Candle | undefined,
+  timeframe: number,
+  value: decimal,
+  timestamp: number
+) {
   const frame = tf(timestamp, timeframe);
 
   if (!candle) {
@@ -23,6 +29,7 @@ function aggregate(candle: Candle, timeframe: number, value: decimal, timestamp:
 
   if (candle.timestamp === frame) {
     candle.apply(value);
+    return undefined;
   } else {
     return new Candle(frame, candle.close, value, value, value);
   }
@@ -31,7 +38,7 @@ function aggregate(candle: Candle, timeframe: number, value: decimal, timestamp:
 export function candle<T extends { timestamp: number }>(
   timeframe: number,
   fn: (x: T) => decimal,
-  candleToStartWith: Candle = undefined
+  candleToStartWith?: Candle
 ) {
   return function (source: Observable<T>): Observable<Candle> {
     let candle = candleToStartWith;
@@ -45,7 +52,12 @@ export function candle<T extends { timestamp: number }>(
 
           if (candleToStartWith && candleToStartWith.timestamp < newCandle.timestamp) {
             candleToStartWith = undefined;
-            return [prevCandle, candle];
+
+            if (prevCandle) {
+              return [prevCandle, candle];
+            }
+
+            return [candle];
           }
         }
 
@@ -53,7 +65,11 @@ export function candle<T extends { timestamp: number }>(
           candleToStartWith = undefined;
         }
 
-        return [candle];
+        if (candle) {
+          return [candle];
+        }
+
+        return [];
       }),
       mergeMap(it => it),
       share()
@@ -101,7 +117,7 @@ export function candleCompleted(): (source: Observable<Candle>) => Observable<Ca
           return undefined;
         }
       }),
-      filter(it => !!it),
+      filter(it => it !== undefined) as OperatorFunction<Candle | undefined, Candle>,
       share()
     );
 }

package/src/domain/commission.ts

@@ -1,6 +1,8 @@
-import { decimal } from '../shared';
+import { d, decimal } from '../shared';
 
 export class Commission {
+  static readonly Zero = commissionPercentOf({ maker: d.Zero, taker: d.Zero });
+
   constructor(readonly makerRate: decimal, readonly takerRate: decimal) {}
 
   calculateMakerFee(value: decimal) {

package/src/domain/error.ts

@@ -11,15 +11,15 @@ export function insufficientFundsError(
 }
 
 export function invalidArgumentError(value: any) {
-  throw new Error(`invalid argument: ${value}`);
+  return new Error(`invalid argument: ${value}`);
 }
 
 export function invalidAssetSelectorError(selector: string) {
-  throw new Error(`invalid asset selector: ${selector}`);
+  return new Error(`invalid asset selector: ${selector}`);
 }
 
 export function invalidInstrumentSelectorError(selector: string) {
-  throw new Error(`invalid instrument selector: ${selector}`);
+  return new Error(`invalid instrument selector: ${selector}`);
 }
 
 export function adapterMismatchError() {

package/src/domain/index.ts

@@ -1,20 +1,21 @@
 export * from './asset';
 export * from './balance';
-export * from './balance.operator';
+export * from './balance-operator';
 export * from './error';
 export * from './candle';
-export * from './candle.operator';
+export * from './candle-operator';
 export * from './commission';
 export * from './component';
 export * from './instrument';
-export * from './instrument.operator';
+export * from './instrument-operator';
 export * from './order';
-export * from './order.operator';
+export * from './order-operator';
 export * from './orderbook';
-export * from './orderbook.operator';
+export * from './orderbook-operator';
 export * from './position';
-export * from './position.operator';
+export * from './position-operator';
 export * from './session';
+export * from './session-builder';
 export * from './timeframe';
 export * from './trade';
-export * from './trade.operator';
+export * from './trade-operator';

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

@@ -2,16 +2,23 @@ import { Subject } from 'rxjs';
 
 import { State } from '../store';
 import { Asset } from './asset';
+import { Commission } from './commission';
 import { Component } from './component';
 import { Instrument, instrumentOf } from './instrument';
-import { instrument } from './instrument.operator';
+import { instrument } from './instrument-operator';
 
 describe('instrument', () => {
   const state = new State();
 
   beforeEach(() => {
     state.universe.instrument.upsert(
-      new Instrument(new Asset('abc', 'xyz', 4), new Asset('def', 'xyz', 4), 'abc-def')
+      new Instrument(
+        0,
+        new Asset('abc', 'xyz', 4),
+        new Asset('def', 'xyz', 4),
+        'abc-def',
+        Commission.Zero
+      )
     );
   });
 

package/src/domain/instrument.spec.ts

@@ -1,12 +1,19 @@
+import { d } from '../shared';
 import { Asset, assetOf } from './asset';
+import { commissionPercentOf } from './commission';
 import { Instrument, instrumentOf } from './instrument';
 
 describe('Instrument', () => {
   test('should construct a instrument', () => {
     const sut = new Instrument(
+      0,
       new Asset('abc', 'xyz', 4),
       new Asset('def', 'xyz', 4),
-      'abc-def'
+      'abc-def',
+      commissionPercentOf({
+        maker: d.Zero,
+        taker: d.Zero
+      })
     );
 
     expect(sut.base.name).toEqual('abc');

package/src/domain/instrument.ts

@@ -1,4 +1,3 @@
-import { timestamp } from '../shared';
 import { Asset, AssetSelector, AssetSelectorSeparator } from './asset';
 import { Commission } from './commission';
 import { Component } from './component';
@@ -27,13 +26,17 @@ export class InstrumentSelector {
  * Represents trading market which is made up by two trading assets (base and quoted).
  */
 export class Instrument extends InstrumentSelector implements Component {
-  kind = 'instrument';
-  timestamp: timestamp;
-  commission: Commission;
-  cross: Instrument;
-  leverage?: number = null;
-
-  constructor(readonly base: Asset, readonly quote: Asset, readonly raw: string) {
+  readonly kind = 'instrument';
+  readonly cross: Instrument | undefined;
+  leverage: number | undefined = undefined;
+
+  constructor(
+    public timestamp: number,
+    override readonly base: Asset,
+    override readonly quote: Asset,
+    readonly raw: string,
+    public commission: Commission
+  ) {
     super(base.name, quote.name, base.adapterName);
 
     if (base.adapterName != quote.adapterName) {

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

@@ -3,20 +3,23 @@ import { BehaviorSubject, map, Subject } from 'rxjs';
 import { d } from '../shared';
 import { InnerSet, State } from '../store';
 import { Asset } from './asset';
+import { Commission } from './commission';
 import { Component } from './component';
 import { Instrument } from './instrument';
 import { Order } from './order';
-import { order, orders } from './order.operator';
+import { order, orders } from './order-operator';
 
 const instrument = new Instrument(
+  0,
   new Asset('abc', 'xyz', 4),
   new Asset('def', 'xyz', 4),
-  'abc-def'
+  'abc-def',
+  Commission.Zero
 );
 
 describe('order', () => {
   test('should pipe an order', done => {
-    new BehaviorSubject<Component>(Order.market(instrument, d(-100)))
+    new BehaviorSubject<Component>(new Order(0, '1', instrument, d(-100), 0))
       .pipe(order(instrument))
       .subscribe({
         next: it => {
@@ -42,9 +45,9 @@ describe('positions', () => {
   beforeEach(() => {
     state = new State();
 
-    order1 = Order.market(instrument, d(-100));
-    order2 = Order.limit(instrument, d(100), d(10));
-    order3 = Order.market(instrument, d(100));
+    order1 = new Order(0, '1', instrument, d(-100), 0);
+    order2 = new Order(0, '2', instrument, d(100), 0, d(10));
+    order3 = new Order(0, '3', instrument, d(100), 0);
 
     state.order.upsert(new InnerSet<Order>(instrument.id, [order1, order2, order3]));
   });

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

@@ -17,7 +17,7 @@ export function orders(selector: InstrumentSelector, state: State) {
   return (source$: Observable<Component>) =>
     source$.pipe(
       filter(it => it instanceof Order && it.instrument.id == selector.id),
-      map(() => state.order.get(selector.id).asReadonlyArray()),
-      startWith(state.order.get(selector.id).asReadonlyArray())
+      map(() => state.order.get(selector.id)?.asReadonlyArray() ?? []),
+      startWith(state.order.get(selector.id)?.asReadonlyArray() ?? [])
     );
 }

package/src/domain/order.spec.ts

@@ -1,44 +1,43 @@
 import { d } from '../shared';
 import { Asset } from './asset';
+import { Commission } from './commission';
 import { Instrument } from './instrument';
 import { Order } from './order';
 
 describe('Order', () => {
   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 market buy order', () => {
-    const sut = Order.market(instrument, d(100));
+    const sut = new Order(0, '1', instrument, d(100), 0);
 
     expect(sut.quantity).toEqual(d(100));
     expect(sut.rate).toEqual(undefined);
-    expect(sut.type).toEqual('MARKET');
   });
 
   test('should construct a market sell order', () => {
-    const sut = Order.market(instrument, d(-100));
+    const sut = new Order(0, '1', instrument, d(-100), 0);
 
     expect(sut.quantity).toEqual(d(-100));
     expect(sut.rate).toEqual(undefined);
-    expect(sut.type).toEqual('MARKET');
   });
 
   test('should construct a limit buy order', () => {
-    const sut = Order.limit(instrument, d(100), d(2000));
+    const sut = new Order(0, '1', instrument, d(100), 0, d(2000));
 
     expect(sut.quantity).toEqual(d(100));
     expect(sut.rate).toEqual(d(2000));
-    expect(sut.type).toEqual('LIMIT');
   });
 
   test('should construct a limit sell order', () => {
-    const sut = Order.limit(instrument, d(-100), d(2000));
+    const sut = new Order(0, '1', instrument, d(-100), 0, d(2000));
 
     expect(sut.quantity).toEqual(d(-100));
     expect(sut.rate).toEqual(d(2000));
-    expect(sut.type).toEqual('LIMIT');
   });
 });