@quantform/core 0.5.15 → 0.6.4

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

@@ -1,5 +1,11 @@
-import { Asset, commissionPercentOf, Instrument, Order } from '../../../domain';
-import { now } from '../../../shared';
+import {
+  Asset,
+  Commission,
+  commissionPercentOf,
+  Instrument,
+  Order
+} from '../../../domain';
+import { d, now } from '../../../shared';
 import {
   BalancePatchEvent,
   InstrumentPatchEvent,
@@ -11,82 +17,100 @@ import { PaperEngine } from './paper-engine';
 
 describe('PaperEngine', () => {
   const instrument = new Instrument(
+    0,
     new Asset('btc', 'binance', 8),
     new Asset('usdt', 'binance', 2),
-    'binance:btc-usdt'
+    'binance:btc-usdt',
+    Commission.Zero
   );
 
   const commission = commissionPercentOf({
-    maker: 0.1,
-    taker: 0.1
+    maker: d(0.1),
+    taker: d(0.1)
   });
 
   test('should open a new buy market order', () => {
     const store = new Store();
     const engine = new PaperEngine(store);
-    const order = Order.market(instrument, 1.0);
+    const order = new Order(0, '1', instrument, d(1.0), 0);
 
     store.dispatch(
       new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
-      new BalancePatchEvent(instrument.base, 1, 0, now()),
-      new BalancePatchEvent(instrument.quote, 1000, 0, now())
+      new BalancePatchEvent(instrument.base, d(1), d.Zero, now()),
+      new BalancePatchEvent(instrument.quote, d(1000), d.Zero, now())
     );
 
     engine.open(order);
 
+    const pendingOrder = store.snapshot.order.get(instrument.id)?.get(order.id) ?? fail();
+    const balance = store.snapshot.balance.get(instrument.quote.id) ?? fail();
+
     expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(store.snapshot.order.get(instrument.id).get(order.id)).toEqual(order);
-    expect(store.snapshot.balance.get(instrument.quote.id).free).toEqual(0);
-    expect(store.snapshot.balance.get(instrument.quote.id).locked).toEqual(1000);
+    expect(pendingOrder).toEqual(order);
+    expect(balance.free).toEqual(d.Zero);
+    expect(balance.locked).toEqual(d(1000));
   });
 
   test('should open a new sell market order', () => {
     const store = new Store();
     const engine = new PaperEngine(store);
-    const order = Order.market(instrument, -0.6);
+    const order = new Order(0, '1', instrument, d(-0.6), 0);
 
     store.dispatch(
       new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
-      new BalancePatchEvent(instrument.base, 1, 0, now()),
-      new BalancePatchEvent(instrument.quote, 1000, 0, now())
+      new BalancePatchEvent(instrument.base, d(1), d.Zero, now()),
+      new BalancePatchEvent(instrument.quote, d(1000), d.Zero, now())
     );
 
     engine.open(order);
 
+    const pendingOrder = store.snapshot.order.get(instrument.id)?.get(order.id) ?? fail();
+    const balance = store.snapshot.balance.get(instrument.base.id) ?? fail();
+
     expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(store.snapshot.order.get(instrument.id).get(order.id)).toEqual(order);
-    expect(store.snapshot.balance.get(instrument.base.id).free).toEqual(0.4);
-    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(0.6);
+    expect(pendingOrder).toEqual(order);
+    expect(balance.free).toEqual(d(0.4));
+    expect(balance.locked).toEqual(d(0.6));
   });
 
   test('should open and fill a new sell limit order', () => {
     const store = new Store();
     const engine = new PaperEngine(store);
-    const order = Order.limit(instrument, -0.6, 100);
+    const order = new Order(0, '1', instrument, d(-0.6), 0, d(100));
 
     store.dispatch(
       new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
-      new BalancePatchEvent(instrument.base, 1, 0, now()),
-      new BalancePatchEvent(instrument.quote, 1000, 0, now()),
+      new BalancePatchEvent(instrument.base, d(1), d.Zero, now()),
+      new BalancePatchEvent(instrument.quote, d(1000), d.Zero, now()),
       new InstrumentSubscriptionEvent(now(), instrument, true)
     );
 
     engine.open(order);
 
+    const pendingOrder = store.snapshot.order.get(instrument.id)?.get(order.id) ?? fail();
+    const baseBalance = store.snapshot.balance.get(instrument.base.id) ?? fail();
+
     expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(store.snapshot.order.get(instrument.id).get(order.id).state).toEqual(
-      'PENDING'
+    expect(pendingOrder.state).toEqual('PENDING');
+    expect(baseBalance.free).toEqual(d(0.4));
+    expect(baseBalance.locked).toEqual(d(0.6));
+
+    store.dispatch(
+      new OrderbookPatchEvent(
+        instrument,
+        { rate: d(102), quantity: d(1), next: undefined },
+        { rate: d(101), quantity: d(1), next: undefined },
+        now()
+      )
     );
-    expect(store.snapshot.balance.get(instrument.base.id).free).toEqual(0.4);
-    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(0.6);
 
-    store.dispatch(new OrderbookPatchEvent(instrument, 102, 1, 101, 1, now()));
+    const quoteBalance = store.snapshot.balance.get(instrument.quote.id) ?? fail();
 
     expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
-    expect(store.snapshot.order.get(instrument.id).get(order.id).state).toEqual('FILLED');
-    expect(store.snapshot.balance.get(instrument.base.id).free).toEqual(0.4);
-    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(0);
-    expect(store.snapshot.balance.get(instrument.quote.id).free).toEqual(1060.53);
-    expect(store.snapshot.balance.get(instrument.quote.id).locked).toEqual(0);
+    expect(pendingOrder.state).toEqual('FILLED');
+    expect(baseBalance.free).toEqual(d(0.4));
+    expect(baseBalance.locked).toEqual(d.Zero);
+    expect(quoteBalance.free).toEqual(d(1060.53));
+    expect(quoteBalance.locked).toEqual(d.Zero);
   });
 });

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

@@ -1,6 +1,7 @@
 import { tap } from 'rxjs';
 
 import { Order, Orderbook, Trade } from '../../../domain';
+import { d, decimal } from '../../../shared';
 import {
   BalanceLockOrderEvent,
   BalanceTransactEvent,
@@ -13,6 +14,7 @@ import {
   OrderRejectedEvent,
   Store
 } from '../../../store';
+import { instrumentNotSupportedError } from '../../../store/error';
 
 export class PaperEngine {
   constructor(private readonly store: Store) {
@@ -59,69 +61,83 @@ export class PaperEngine {
   }
 
   private onOrderbook(orderbook: Orderbook) {
-    this.store.snapshot.order
-      .get(orderbook.instrument.id)
-      .asReadonlyArray()
-      .forEach(it => {
-        if (it.state != 'PENDING') {
-          return;
-        }
+    const orders = this.store.snapshot.order.get(orderbook.instrument.id);
+    if (!orders) {
+      return;
+    }
 
-        if (it.type == 'LIMIT') {
-          if (it.quantity > 0 && it.rate > orderbook.bestAskRate) {
-            this.completeOrder(it, orderbook.bestAskRate);
-          } else if (it.quantity < 0 && it.rate < orderbook.bestBidRate) {
-            this.completeOrder(it, orderbook.bestBidRate);
-          }
-        } else if (it.type == 'MARKET') {
-          if (it.quantity > 0) {
-            this.completeOrder(it, orderbook.bestAskRate);
-          } else if (it.quantity < 0) {
-            this.completeOrder(it, orderbook.bestBidRate);
-          }
+    orders.asReadonlyArray().forEach(it => {
+      if (it.state != 'PENDING') {
+        return;
+      }
+
+      if (it.rate) {
+        if (it.quantity.greaterThan(0) && it.rate.greaterThan(orderbook.asks.rate)) {
+          this.completeOrder(it, orderbook.asks.rate);
+        } else if (it.quantity.lessThan(0) && it.rate.lessThan(orderbook.bids.rate)) {
+          this.completeOrder(it, orderbook.bids.rate);
+        }
+      } else {
+        if (it.quantity.greaterThan(0)) {
+          this.completeOrder(it, orderbook.asks.rate);
+        } else if (it.quantity.lessThan(0)) {
+          this.completeOrder(it, orderbook.bids.rate);
         }
-      });
+      }
+    });
   }
 
   private onTrade(trade: Trade) {
-    this.store.snapshot.order
-      .get(trade.instrument.id)
-      .asReadonlyArray()
-      .forEach(it => {
-        if (it.state != 'PENDING') {
-          return;
-        }
+    const orders = this.store.snapshot.order.get(trade.instrument.id);
+    if (!orders) {
+      return;
+    }
 
-        if (it.type == 'LIMIT') {
-          if (it.quantity > 0 && it.rate > trade.rate) {
-            this.completeOrder(it, trade.rate);
-          } else if (it.quantity < 0 && it.rate < trade.rate) {
-            this.completeOrder(it, trade.rate);
-          }
-        } else if (it.type == 'MARKET') {
+    orders.asReadonlyArray().forEach(it => {
+      if (it.state != 'PENDING') {
+        return;
+      }
+
+      if (it.rate) {
+        if (it.quantity.greaterThan(0) && it.rate.greaterThan(trade.rate)) {
+          this.completeOrder(it, trade.rate);
+        } else if (it.quantity.lessThan(0) && it.rate.lessThan(trade.rate)) {
           this.completeOrder(it, trade.rate);
         }
-      });
+      } else {
+        this.completeOrder(it, trade.rate);
+      }
+    });
   }
 
-  private completeOrder(order: Order, averageExecutionRate: number) {
+  private completeOrder(order: Order, averageExecutionRate: decimal) {
     const { timestamp } = this.store.snapshot;
 
     const instrument = this.store.snapshot.universe.instrument.get(order.instrument.id);
+    if (!instrument) {
+      throw instrumentNotSupportedError(order.instrument);
+    }
+
     const transacted = {
-      base: 0,
-      quote: 0
+      base: d.Zero,
+      quote: d.Zero
     };
 
-    const qty = Math.abs(order.quantity);
+    const qty = order.quantity.abs();
 
-    if (order.quantity > 0) {
-      transacted.base += instrument.base.floor(instrument.commission.applyMakerFee(qty));
-      transacted.quote -= instrument.quote.floor(averageExecutionRate * qty);
-    } else if (order.quantity < 0) {
-      transacted.base -= instrument.base.floor(qty);
-      transacted.quote += instrument.quote.floor(
-        instrument.commission.applyMakerFee(averageExecutionRate * qty)
+    if (order.quantity.greaterThan(0)) {
+      transacted.base = transacted.base.plus(
+        instrument.base.floor(instrument.commission.applyMakerFee(qty))
+      );
+      transacted.quote = transacted.quote.minus(
+        instrument.quote.floor(averageExecutionRate.mul(qty))
+      );
+    } else if (order.quantity.lessThan(0)) {
+      transacted.base = transacted.base.minus(instrument.base.floor(qty));
+      transacted.quote = transacted.quote.plus(
+        instrument.quote.floor(
+          instrument.commission.applyMakerFee(averageExecutionRate.mul(qty))
+        )
       );
     }
 

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

@@ -1,11 +1,13 @@
 import { assetOf, Candle, InstrumentSelector, Order } from '../../domain';
+import { d, decimal, timestamp } from '../../shared';
 import { BalancePatchEvent, Store } from '../../store';
 import { Adapter } from '..';
-import { AdapterFactory, FeedQuery, HistoryQuery } from '../adapter';
+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(
@@ -18,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,
@@ -60,28 +62,47 @@ export class PaperAdapter extends Adapter {
 
       subscribed = subscribed.filter(it => it.id != asset.id);
 
-      this.store.dispatch(new BalancePatchEvent(asset, free, 0, this.timestamp()));
+      this.store.dispatch(new BalancePatchEvent(asset, free, d.Zero, this.timestamp()));
     }
 
     for (const missingAsset of subscribed) {
-      this.store.dispatch(new BalancePatchEvent(missingAsset, 0, 0, this.timestamp()));
+      this.store.dispatch(
+        new BalancePatchEvent(missingAsset, d.Zero, d.Zero, this.timestamp())
+      );
     }
   }
 
   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);
   }
 
-  history(query: HistoryQuery): Promise<Candle[]> {
-    return this.decoratedAdapter.history(query);
+  history(
+    instrument: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]> {
+    return this.decoratedAdapter.history(instrument, timeframe, length);
   }
 
-  feed(query: FeedQuery): Promise<void> {
-    return this.decoratedAdapter.feed(query);
+  feed(
+    instrument: InstrumentSelector,
+    from: timestamp,
+    to: timestamp,
+    callback: FeedAsyncCallback
+  ): Promise<void> {
+    return this.decoratedAdapter.feed(instrument, from, to, callback);
   }
 
   createPaperEngine(adapter: PaperAdapter): PaperEngine {

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 { SessionBuilder } from '../domain/session-builder';
+import { 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: 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 prepare(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,66 +1,58 @@
 import { Presets, SingleBar } from 'cli-progress';
+import { join } from 'path';
 
-import { Bootstrap } from '../bootstrap';
 import { instrumentOf } from '../domain';
+import { SessionBuilder } from '../domain/session-builder';
+import { now } from '../shared';
 import { Feed } from '../storage';
+import { prepare } from '../strategy';
 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 builder = new SessionBuilder().useSessionId(
+    options.id ? Number(options.id) : now()
+  );
 
-  const module = await getModule(name);
+  await prepare(name, builder);
 
-  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.'
-    );
-  }
+  const session = builder.paper();
 
   console.time('Pulling completed in');
 
-  await session.awake(undefined);
+  await session.awake();
 
-  const bar = new SingleBar({}, Presets.shades_classic);
-  const feed = new Feed(module.descriptor.storage('feed'));
+  const bar = new SingleBar(
+    {
+      format: `Pulling ${instrument} [{bar}] {percentage}% | ETA: {eta}s | {value}/{total}`
+    },
+    Presets.rect
+  );
+
+  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);
 
-  await session.aggregate.feed({
-    instrument: instrumentOf(instrument),
+  await session.aggregate.feed(
+    instrumentOf(instrument),
     from,
     to,
-    destination: feed,
-    callback: timestamp => {
+    async (timestamp, events) => {
       const duration = to - from;
       const completed = timestamp - from;
 
+      await feed.save(events);
+
       bar.update(Math.floor((completed / duration) * 100));
     }
-  });
+  );
 
   bar.update(100);
   bar.stop();

package/src/cli/run.ts

@@ -1,22 +1,25 @@
-import * as dotenv from 'dotenv';
+import { join } from 'path';
 
-import { Bootstrap } from '../bootstrap';
+import { SessionBuilder } from '../domain/session-builder';
+import { 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;
   }
+  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 prepare(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 { 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.spec.ts

@@ -1,3 +1,4 @@
+import { d } from '../shared';
 import { Asset, assetOf } from './asset';
 
 describe('Asset', () => {
@@ -7,10 +8,9 @@ describe('Asset', () => {
     expect(sut.name).toEqual('abc');
     expect(sut.adapterName).toEqual('xyz');
     expect(sut.scale).toEqual(4);
-    expect(sut.tickSize).toEqual(0.0001);
-    expect(sut.fixed(1.1234567)).toEqual(1.1234);
-    expect(sut.floor(1.1234567)).toEqual(1.1234);
-    expect(sut.ceil(1.1234567)).toEqual(1.1235);
+    expect(sut.tickSize).toEqual(d(0.0001));
+    expect(sut.floor(d(1.1234567))).toEqual(d(1.1234));
+    expect(sut.ceil(d(1.1234567))).toEqual(d(1.1235));
     expect(sut.id).toEqual('xyz:abc');
   });