@quantform/core 0.4.9 → 0.5.14

package/src/adapter/adapter.ts

@@ -1,6 +1,6 @@
 import { Candle, InstrumentSelector, Order } from '../domain';
 import { now, timestamp } from '../shared';
-import { Feed } from '../storage';
+import { Cache, Feed } from '../storage';
 import { State, Store, StoreEvent } from '../store';
 import { PaperAdapter } from './paper';
 import { PaperSimulator } from './paper/simulator/paper-simulator';
@@ -20,7 +20,11 @@ export class AdapterContext {
     return this.store.snapshot;
   }
 
-  constructor(private readonly adapter: Adapter, private readonly store: Store) {}
+  constructor(
+    private readonly adapter: Adapter,
+    private readonly store: Store,
+    readonly cache: Cache
+  ) {}
 
   dispatch(...events: StoreEvent[]) {
     return this.store.dispatch(...events);
@@ -65,7 +69,9 @@ export abstract class Adapter {
   /**
    * Dispose an adapter.
    */
-  async dispose(): Promise<void> {}
+  async dispose(): Promise<void> {
+    throw new Error('method not implemented');
+  }
 
   /**
    * Subscribe to collection of instruments.

package/src/adapter/backtester/backtester-adapter.ts

@@ -1,7 +1,7 @@
-import { Adapter, AdapterContext } from '..';
 import { Candle, InstrumentSelector, Order } from '../../domain';
 import { timestamp } from '../../shared';
 import { InstrumentSubscriptionEvent } from '../../store';
+import { Adapter, AdapterContext } from '..';
 import { FeedQuery, HistoryQuery } from '../adapter';
 import { PaperAdapter, PaperOptions } from '../paper';
 import { PaperSimulator } from '../paper/simulator/paper-simulator';
@@ -42,6 +42,8 @@ export class BacktesterAdapter extends Adapter {
         it => new InstrumentSubscriptionEvent(this.context.timestamp, it, true)
       )
     );
+
+    this.streamer.tryContinue();
   }
 
   account(): Promise<void> {

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

@@ -1,8 +1,9 @@
-import { PaperSpotSimulator } from '.';
-import { AdapterContext } from '..';
+import { Cache, InMemoryStorage } from '../../storage';
 import { InstrumentPatchEvent, Store } from '../../store';
+import { AdapterContext } from '..';
 import { Adapter } from '../adapter';
 import { Asset, Commission, instrumentOf, Order } from './../../domain';
+import { PaperSpotSimulator } from '.';
 import { PaperAdapter } from './paper-adapter';
 import { PaperSimulator } from './simulator/paper-simulator';
 
@@ -52,10 +53,11 @@ describe('paper adapter tests', () => {
   test('', async () => {
     const store = new Store();
     const adapter = new DefaultAdapter();
+    const cache = new Cache(new InMemoryStorage());
 
     const sut = new PaperAdapter(adapter, store, options);
 
-    await sut.awake(new AdapterContext(sut, store));
+    await sut.awake(new AdapterContext(sut, store, cache));
     await sut.account();
 
     const order = Order.buyMarket(instrumentOf('default:a-b'), 1.0);

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

@@ -1,6 +1,6 @@
-import { Adapter, AdapterContext } from '..';
 import { assetOf, Candle, InstrumentSelector, Order } from '../../domain';
 import { BalancePatchEvent, Store } from '../../store';
+import { Adapter, AdapterContext } from '..';
 import { FeedQuery, HistoryQuery } from '../adapter';
 import { PaperSimulator } from './simulator/paper-simulator';
 

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

@@ -1,4 +1,3 @@
-import { PaperAdapter } from '..';
 import { Order } from '../../../domain';
 import { pnl, weightedMean } from '../../../shared';
 import {
@@ -10,6 +9,7 @@ import {
   OrderPendingEvent,
   PositionPatchEvent
 } from '../../../store';
+import { PaperAdapter } from '..';
 import { PaperSimulator } from './paper-simulator';
 
 export class PaperMarginSimulator extends PaperSimulator {

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

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

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

@@ -1,4 +1,3 @@
-import { PaperAdapter } from '..';
 import { Order } from '../../../domain';
 import { timestamp } from '../../../shared';
 import {
@@ -11,6 +10,7 @@ import {
   OrderNewEvent,
   OrderPendingEvent
 } from '../../../store';
+import { PaperAdapter } from '..';
 import { PaperSimulator } from './paper-simulator';
 
 export class PaperSpotSimulator extends PaperSimulator {
@@ -111,7 +111,7 @@ export class PaperSpotSimulator extends PaperSimulator {
         switch (order.type) {
           case 'MARKET':
             return [
-              new BalanceUnfreezEvent(order.instrument.quote, quote.freezed, timestamp)
+              new BalanceUnfreezEvent(order.instrument.quote, quote.locked, timestamp)
             ];
 
           case 'LIMIT':

package/src/bootstrap.ts

@@ -6,6 +6,7 @@ import {
   PaperAdapter
 } from './adapter';
 import { Session, SessionDescriptor } from './domain';
+import { Cache, Feed, InMemoryStorage, InMemoryStorageFactory } from './storage';
 import { Store } from './store';
 
 export class Bootstrap {
@@ -29,12 +30,20 @@ export class Bootstrap {
    * @param to
    */
   useBacktestPeriod(from?: number, to?: number): Bootstrap {
+    if (!this.descriptor.simulation) {
+      this.descriptor.simulation = {
+        balance: {},
+        from: undefined,
+        to: undefined
+      };
+    }
+
     if (from) {
-      this.descriptor.options.backtester.from = from;
+      this.descriptor.simulation.from = from;
     }
 
     if (to) {
-      this.descriptor.options.backtester.to = to;
+      this.descriptor.simulation.to = to;
     }
 
     return this;
@@ -47,16 +56,27 @@ export class Bootstrap {
    */
   backtest(listener?: BacktesterListener): [Session, BacktesterStreamer] {
     const store = new Store();
-    const { feed } = this.descriptor;
-    const { backtester } = this.descriptor.options;
-
-    const streamer = new BacktesterStreamer(store, feed, backtester, listener);
+    const { storage } = this.descriptor;
+    const feed = new Feed(storage.create('feed'));
+    const cache = new Cache(storage.create('cache'));
+
+    const streamer = new BacktesterStreamer(
+      store,
+      feed,
+      this.descriptor.simulation,
+      listener
+    );
 
     const aggregate = new AdapterAggregate(
       this.descriptor.adapter.map(
-        it => new BacktesterAdapter(new PaperAdapter(it, store, backtester), streamer)
+        it =>
+          new BacktesterAdapter(
+            new PaperAdapter(it, store, this.descriptor.simulation),
+            streamer
+          )
       ),
-      store
+      store,
+      cache
     );
 
     const session = new Session(store, aggregate, this.descriptor);
@@ -69,22 +89,28 @@ export class Bootstrap {
    * @returns new session object.
    */
   paper(): Session {
-    if (!this.descriptor.options) {
-      this.descriptor.options = {};
+    if (!this.descriptor.simulation) {
+      this.descriptor.simulation = {
+        balance: {},
+        from: undefined,
+        to: undefined
+      };
     }
 
-    if (!this.descriptor.options.paper) {
-      this.descriptor.options.paper = {
-        balance: {}
-      };
+    if (!this.descriptor.simulation.balance) {
+      this.descriptor.simulation.balance = {};
     }
 
     const store = new Store();
-    const { paper } = this.descriptor.options;
+    const storage = this.descriptor.storage ?? new InMemoryStorageFactory();
+    const cache = new Cache(storage.create('cache'));
 
     const aggregate = new AdapterAggregate(
-      this.descriptor.adapter.map(it => new PaperAdapter(it, store, paper)),
-      store
+      this.descriptor.adapter.map(
+        it => new PaperAdapter(it, store, this.descriptor.simulation)
+      ),
+      store,
+      cache
     );
 
     return new Session(store, aggregate, this.descriptor);
@@ -96,7 +122,10 @@ export class Bootstrap {
    */
   live(): Session {
     const store = new Store();
-    const aggregate = new AdapterAggregate(this.descriptor.adapter, store);
+    const storage = this.descriptor.storage ?? new InMemoryStorageFactory();
+    const cache = new Cache(storage.create('cache'));
+
+    const aggregate = new AdapterAggregate(this.descriptor.adapter, store, cache);
 
     return new Session(store, aggregate, this.descriptor);
   }

package/src/cli/build.ts

@@ -0,0 +1,15 @@
+import { spawn } from 'child_process';
+
+import { buildDirectory } from './internal/workspace';
+
+export default async function (): Promise<number> {
+  return new Promise<number>((resolve, reject) => {
+    const process = spawn('swc', ['./src', '--out-dir', buildDirectory()], {
+      stdio: 'inherit',
+      shell: false
+    });
+
+    process.once('exit', resolve);
+    process.once('error', reject);
+  });
+}

package/src/cli/dev.ts

@@ -0,0 +1,18 @@
+import { Bootstrap } from '../bootstrap';
+import build from './build';
+import { getModule } from './internal/workspace';
+
+export default async function (name: string, options: any) {
+  if (await build()) {
+    return;
+  }
+
+  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();
+
+  await session.awake(module.default);
+}

package/src/cli/index.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+import { ChildProcess, spawn } from 'child_process';
+import { program } from 'commander';
+import watch from 'node-watch';
+
+import build from './build';
+import dev from './dev';
+import pull from './pull';
+import run from './run';
+import test from './test';
+
+program
+  .command('build')
+  .description('builds a production version of the app')
+  .action(async () => {
+    await build();
+  });
+
+program
+  .command('run')
+  .argument('<name>', 'strategy to execute')
+  .option('-i, --id <id>', 'session identifier')
+  .option('-w', 'watch mode')
+  .description('executes strategy in live trading mode')
+  .action(run);
+
+program
+  .command('dev')
+  .argument('<name>', 'strategy to execute')
+  .option('-i, --id <id>', 'session identifier')
+  .option('-w', 'watch mode')
+  .description('executes strategy in paper e.g. simulation mode')
+  .action(dev);
+
+program
+  .command('test')
+  .description('executes strategy in backtesting mode for specified period')
+  .argument('<name>', 'strategy to execute')
+  .option('-f, --from <from>', 'date from')
+  .option('-t, --to <to>', 'date to')
+  .option('-w', 'watch mode')
+  .action(test);
+
+program
+  .command('pull')
+  .description('pulls instrument historical data to storage')
+  .argument('<name>', 'strategy to execute')
+  .argument('<instrument>', 'instrument to import')
+  .option('-f, --from <from>', 'date from')
+  .option('-t, --to <to>', 'date to')
+  .action(pull);
+
+program.name('quantform').description('quantform tools');
+
+if (process.argv.length < 3) {
+  program.help();
+} else {
+  if (process.argv.every(it => it != '-w')) {
+    program.parse(process.argv);
+  } else {
+    const argv = process.argv.splice(1).filter(it => it != '-w');
+    let child: ChildProcess;
+
+    const spawnChildProcess = () => {
+      console.clear();
+
+      if (child) {
+        child.kill();
+      }
+
+      child = spawn('node', argv, {
+        stdio: ['inherit', 'inherit', 'inherit', 'ipc']
+      });
+    };
+
+    spawnChildProcess();
+
+    watch(process.cwd() + '/src', { recursive: true }, () => spawnChildProcess());
+  }
+}

package/src/cli/internal/workspace.ts

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

@@ -0,0 +1,67 @@
+import { Presets, SingleBar } from 'cli-progress';
+
+import { Bootstrap } from '../bootstrap';
+import { instrumentOf } from '../domain';
+import { Feed } from '../storage';
+import build from './build';
+import { getModule } from './internal/workspace';
+
+export default async function (name: string, instrument: string, options: any) {
+  if (await build()) {
+    return;
+  }
+
+  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 to = options.to ? Date.parse(options.to) : module.descriptor.simulation.to;
+
+  if (!to) {
+    throw new Error(
+      'Please set a "to" date in session descriptor or provide the date as parameter.'
+    );
+  }
+
+  await session.awake(undefined);
+
+  const bar = new SingleBar({}, Presets.shades_classic);
+  const feed = new Feed(module.descriptor.storage.create('feed'));
+
+  bar.start(100, 0);
+
+  await session.aggregate.feed({
+    instrument: instrumentOf(instrument),
+    from,
+    to,
+    destination: feed,
+    callback: timestamp => {
+      const duration = to - from;
+      const completed = timestamp - from;
+
+      bar.update(Math.floor((completed / duration) * 100));
+    }
+  });
+
+  bar.update(100);
+  bar.stop();
+
+  await session.dispose();
+}

package/src/cli/run.ts

@@ -0,0 +1,22 @@
+import * as dotenv from 'dotenv';
+
+import { Bootstrap } from '../bootstrap';
+import build from './build';
+import { getModule } from './internal/workspace';
+
+export default async function (name, options: any) {
+  if (await build()) {
+    return;
+  }
+
+  dotenv.config();
+
+  const id = options.id ? Number(options.id) : undefined;
+
+  const module = await getModule(name);
+
+  const bootstrap = new Bootstrap(module.descriptor);
+  const session = bootstrap.useSessionId(id).live();
+
+  await session.awake(module.default);
+}

package/src/cli/test.ts

@@ -0,0 +1,50 @@
+import { BacktesterStreamer } from '../adapter';
+import { Bootstrap } from '../bootstrap';
+import build from './build';
+import { getModule } from './internal/workspace';
+
+export default async function (name, options: any) {
+  if (await build()) {
+    return;
+  }
+
+  const module = await getModule(name);
+
+  const bootstrap = new Bootstrap(module.descriptor);
+
+  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 to = options.to ? Date.parse(options.to) : module.descriptor.simulation.to;
+
+  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({
+      onBacktestCompleted: async () => {
+        await session.dispose();
+
+        console.log('backtest completed.');
+
+        resolve();
+      }
+    });
+
+    await session.awake(module.default);
+  });
+}

package/src/domain/balance.spec.ts

@@ -7,7 +7,7 @@ describe('balance tests', () => {
 
     expect(sut.asset.toString()).toEqual('xyz:abc');
     expect(sut.free).toEqual(0);
-    expect(sut.freezed).toEqual(0);
+    expect(sut.locked).toEqual(0);
     expect(Object.keys(sut.position).length).toEqual(0);
   });
 
@@ -18,7 +18,7 @@ describe('balance tests', () => {
 
     expect(sut.asset.toString()).toEqual('xyz:abc');
     expect(sut.free).toEqual(100);
-    expect(sut.freezed).toEqual(50);
+    expect(sut.locked).toEqual(50);
     expect(Object.keys(sut.position).length).toEqual(0);
   });
 });

package/src/domain/balance.ts

@@ -7,19 +7,20 @@ import { Position, PositionMode } from './position';
  * Represents single asset balance in your wallet.
  */
 export class Balance implements Component {
+  kind = 'balance';
   timestamp: timestamp;
 
   readonly maintenanceMarginRate = 1;
 
-  private _free = 0;
-  private _freezed = 0;
+  private available = 0;
+  private unavailable = 0;
 
   /**
    * Returns available amount to trade.
    */
   get free(): number {
     return (
-      this._free +
+      this.available +
       this.getEstimatedUnrealizedPnL('CROSS') -
       this.getEstimatedMaintenanceMargin('CROSS')
     );
@@ -28,8 +29,8 @@ export class Balance implements Component {
   /**
    * Return locked amount for order.
    */
-  get freezed(): number {
-    return this._freezed;
+  get locked(): number {
+    return this.unavailable;
   }
 
   /**
@@ -38,7 +39,7 @@ export class Balance implements Component {
    */
   get total(): number {
     return (
-      this._free + this._freezed + this.getEstimatedUnrealizedPnL() /* +
+      this.available + this.unavailable + this.getEstimatedUnrealizedPnL() /* +
       this.getEstimatedMaintenanceMargin()*/
     );
   }
@@ -51,20 +52,20 @@ export class Balance implements Component {
   constructor(public readonly asset: Asset) {}
 
   transact(amount: number) {
-    if (this._free + amount < 0) {
-      throw new Error(`invalid balance amount has: ${this._free} wants: ${amount}`);
+    if (this.available + amount < 0) {
+      throw new Error(`invalid balance amount has: ${this.available} wants: ${amount}`);
     }
 
-    this._free += amount;
+    this.available += amount;
   }
 
   set(free: number, freezed: number) {
     if (free != null) {
-      this._free = free;
+      this.available = free;
     }
 
     if (freezed != null) {
-      this._freezed = freezed;
+      this.unavailable = freezed;
     }
   }
 
@@ -73,21 +74,21 @@ export class Balance implements Component {
    * If you place new pending order, you will lock your balance to fund order.
    */
   freez(amount: number) {
-    if (this._free < amount) {
-      throw new Error(`insufficient funds has: ${this._free} wants: ${amount}`);
+    if (this.available < amount) {
+      throw new Error(`insufficient funds has: ${this.available} wants: ${amount}`);
     }
 
-    this._free -= amount;
-    this._freezed += amount;
+    this.available -= amount;
+    this.unavailable += amount;
   }
 
   unfreez(amount: number) {
-    if (this._freezed < amount) {
-      throw new Error(`insufficient funds has: ${this._freezed} wants: ${amount}`);
+    if (this.unavailable < amount) {
+      throw new Error(`insufficient funds has: ${this.unavailable} wants: ${amount}`);
     }
 
-    this._free += amount;
-    this._freezed -= amount;
+    this.available += amount;
+    this.unavailable -= amount;
   }
 
   /**

package/src/domain/candle.spec.ts

@@ -1,4 +1,5 @@
 import { from, map } from 'rxjs';
+
 import { now } from '../shared';
 import { TradePatchEvent } from '../store';
 import { Candle, mergeCandle } from './candle';