@quantform/core 0.5.23 → 0.6.5

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

@@ -1,12 +1,13 @@
-import { assetOf, Candle, InstrumentSelector, Order } from '../../domain';
-import { d, timestamp } from '../../shared';
+import { assetOf, InstrumentSelector, Ohlc, Order } from '../../domain';
+import { d, decimal, timestamp } from '../../shared';
 import { BalancePatchEvent, Store } from '../../store';
 import { Adapter } from '..';
 import { AdapterFactory, FeedAsyncCallback } from '../adapter';
+import { noPaperEngineProvidedError } from '../error';
 import { PaperEngine } from './engine/paper-engine';
 
 export interface PaperOptions {
-  balance: { [key: string]: number };
+  balance: { [key: string]: decimal };
 }
 
 export function createPaperAdapterFactory(
@@ -19,7 +20,7 @@ export function createPaperAdapterFactory(
 
 export class PaperAdapter extends Adapter {
   readonly name = this.decoratedAdapter.name;
-  private engine: PaperEngine;
+  private engine?: PaperEngine;
 
   constructor(
     readonly decoratedAdapter: Adapter,
@@ -57,7 +58,7 @@ export class PaperAdapter extends Adapter {
         continue;
       }
 
-      const free = d(this.options.balance[balance]);
+      const free = this.options.balance[balance];
 
       subscribed = subscribed.filter(it => it.id != asset.id);
 
@@ -72,10 +73,18 @@ export class PaperAdapter extends Adapter {
   }
 
   async open(order: Order): Promise<void> {
+    if (!this.engine) {
+      throw noPaperEngineProvidedError();
+    }
+
     this.engine.open(order);
   }
 
   async cancel(order: Order): Promise<void> {
+    if (!this.engine) {
+      throw noPaperEngineProvidedError();
+    }
+
     this.engine.cancel(order);
   }
 
@@ -83,7 +92,7 @@ export class PaperAdapter extends Adapter {
     instrument: InstrumentSelector,
     timeframe: number,
     length: number
-  ): Promise<Candle[]> {
+  ): Promise<Ohlc[]> {
     return this.decoratedAdapter.history(instrument, timeframe, length);
   }
 

package/src/cli/build.ts

@@ -6,7 +6,7 @@ export default async function (): Promise<number> {
   return new Promise<number>((resolve, reject) => {
     const process = spawn('swc', ['./src', '--out-dir', buildDirectory()], {
       stdio: 'inherit',
-      shell: false
+      shell: true
     });
 
     process.once('exit', resolve);

package/src/cli/dev.ts

@@ -1,18 +1,26 @@
-import { Bootstrap } from '../bootstrap';
+import { join } from 'path';
+
+import { spawn } from '..';
+import { SessionBuilder } from '../domain/session-builder';
+import { now } from '../shared';
 import build from './build';
-import { getModule } from './internal/workspace';
+import { buildDirectory } from './internal/workspace';
 
 export default async function (name: string, options: any) {
   if (await build()) {
     return;
   }
 
-  const id = options.id ? Number(options.id) : undefined;
+  await import(join(buildDirectory(), 'index'));
+
+  const builder = new SessionBuilder().useSessionId(
+    options.id ? Number(options.id) : now()
+  );
 
-  const module = await getModule(name);
+  const rules = await spawn(name, builder);
 
-  const bootstrap = new Bootstrap(module.descriptor);
-  const session = bootstrap.useSessionId(id).paper();
+  const session = builder.paper();
+  await session.awake();
 
-  await session.awake(module.default);
+  rules(session).subscribe();
 }

package/src/cli/error.ts

@@ -0,0 +1,5 @@
+export function missingDescriptorParameterError(parameterName: string) {
+  return new Error(
+    `please set a "${parameterName}" date in session descriptor or provide the date as parameter.`
+  );
+}

package/src/cli/internal/workspace.ts

@@ -1,18 +1,7 @@
 import { join } from 'path';
-import { Observable } from 'rxjs';
 
-import { Session, SessionDescriptor } from './../../domain';
 import { workingDirectory } from './../../shared';
 
-export type StrategyModule = {
-  descriptor: SessionDescriptor;
-  default: (session: Session) => Observable<any>;
-};
-
 export function buildDirectory() {
   return join(process.cwd(), workingDirectory(), 'build');
 }
-
-export async function getModule(name: string): Promise<StrategyModule> {
-  return await import(join(buildDirectory(), name));
-}

package/src/cli/pull.ts

@@ -1,51 +1,42 @@
 import { Presets, SingleBar } from 'cli-progress';
+import { join } from 'path';
 
-import { Bootstrap } from '../bootstrap';
+import { spawn } from '..';
 import { instrumentOf } from '../domain';
+import { SessionBuilder } from '../domain/session-builder';
+import { now } from '../shared';
 import { Feed } from '../storage';
 import build from './build';
-import { getModule } from './internal/workspace';
+import { buildDirectory } from './internal/workspace';
 
 export default async function (name: string, instrument: string, options: any) {
   if (await build()) {
     return;
   }
+  await import(join(buildDirectory(), 'index'));
 
-  const id = options.id ? Number(options.id) : undefined;
-
-  const module = await getModule(name);
-
-  const bootstrap = new Bootstrap(module.descriptor);
-  const session = bootstrap.useSessionId(id).paper();
-
-  if (!module.descriptor.storage) {
-    throw new Error('Please provide a "storage" property in session descriptor.');
-  }
-
-  const from = options.from
-    ? Date.parse(options.from)
-    : module.descriptor.simulation.from;
-
-  if (!from) {
-    throw new Error(
-      'Please set a "from" date in session descriptor or provide the date as parameter.'
-    );
-  }
+  const builder = new SessionBuilder().useSessionId(
+    options.id ? Number(options.id) : now()
+  );
 
-  const to = options.to ? Date.parse(options.to) : module.descriptor.simulation.to;
+  await spawn(name, builder);
 
-  if (!to) {
-    throw new Error(
-      'Please set a "to" date in session descriptor or provide the date as parameter.'
-    );
-  }
+  const session = builder.paper();
 
   console.time('Pulling completed in');
 
-  await session.awake(undefined);
+  await session.awake();
+
+  const bar = new SingleBar(
+    {
+      format: `Pulling ${instrument} [{bar}] {percentage}% | ETA: {eta}s | {value}/{total}`
+    },
+    Presets.rect
+  );
 
-  const bar = new SingleBar({}, Presets.shades_classic);
-  const feed = new Feed(module.descriptor.storage('feed'));
+  const feed = new Feed(builder.storage('feed'));
+  const from = options.from ? Date.parse(options.from) : builder.period.from;
+  const to = options.to ? Date.parse(options.to) : builder.period.to;
 
   bar.start(100, 0);
 

package/src/cli/run.ts

@@ -1,22 +1,25 @@
-import * as dotenv from 'dotenv';
+import { join } from 'path';
 
-import { Bootstrap } from '../bootstrap';
+import { spawn } from '..';
+import { SessionBuilder } from '../domain/session-builder';
+import { now } from '../shared';
 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;
   }
+  await import(join(buildDirectory(), 'index'));
 
-  dotenv.config();
+  const builder = new SessionBuilder().useSessionId(
+    options.id ? Number(options.id) : now()
+  );
 
-  const id = options.id ? Number(options.id) : undefined;
+  const rules = await spawn(name, builder);
 
-  const module = await getModule(name);
+  const session = builder.live();
+  await session.awake();
 
-  const bootstrap = new Bootstrap(module.descriptor);
-  const session = bootstrap.useSessionId(id).live();
-
-  await session.awake(module.default);
+  rules(session).subscribe();
 }

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 { spawn } from '..';
 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 spawn(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;
@@ -24,13 +24,6 @@ export class AssetSelector {
     this.adapterName = adapterName.toLowerCase();
     this.id = `${this.adapterName}${AssetSelectorSeparator}${this.name}`;
   }
-
-  /**
-   * Returns unified notation of the asset.
-   */
-  toString(): string {
-    return this.id;
-  }
 }
 
 /**

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';
@@ -9,8 +9,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 +43,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 +104,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
     );
   }
@@ -120,8 +120,4 @@ export class Balance implements Component {
       d.Zero
     );
   }
-
-  toString() {
-    return this.asset.toString();
-  }
 }

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/component.ts

@@ -2,6 +2,5 @@ import { timestamp } from '../shared';
 
 export interface Component {
   id: string;
-  kind: string;
   timestamp: timestamp;
 }

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 './ohlc';
+export * from './ohlc-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');