@quantform/core 0.5.23 → 0.6.5

package/jest.config.ts

@@ -0,0 +1,13 @@
+import { Config } from 'jest';
+
+const config: Config = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/src/**/?(*.)+(spec|test).[jt]s?(x)'],
+  transform: {
+    '^.+\\.ts?$': 'ts-jest'
+  },
+  testPathIgnorePatterns: ['src/cli/test.ts']
+};
+
+export default config;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@quantform/core",
-  "version": "0.5.23",
-  "author": "Mateusz Majchrzak",
+  "version": "0.6.5",
   "license": "MIT",
+  "author": "Mateusz Majchrzak",
   "description": "Node.js library for building systematic trading strategies in reactive way.",
   "repository": {
     "type": "git",
@@ -15,42 +15,29 @@
     "qf": "./dist/cli/index.js"
   },
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "prepare": "npm run build",
-    "build": "tsc",
-    "test": "jest -c jestconfig.json --coverage --passWithNoTests"
-  },
+  "typings": "dist/index.d.ts",
   "dependencies": {
     "@swc/cli": "^0.1.57",
-    "@swc/core": "^1.2.170",
-    "@types/decimal.js": "^7.4.0",
-    "cli-progress": "^3.10.0",
-    "commander": "^9.1.0",
-    "decimal.js": "^10.3.1",
-    "dotenv": "^16.0.0",
+    "@swc/core": "^1.3.1",
+    "chalk": "4.1.2",
+    "cli-progress": "^3.11.2",
+    "commander": "^9.4.0",
+    "decimal.js": "^10.4.1",
     "node-watch": "^0.7.3",
-    "reflect-metadata": "^0.1.13",
-    "ts-retry": "^2.4.0",
-    "typescript-collections": "^1.3.3",
-    "uuid": "^8.3.2"
-  },
-  "peerDependencies": {
-    "rxjs": "*"
+    "ts-retry": "^2.4.5",
+    "uuid": "^9.0.0"
   },
   "devDependencies": {
-    "@types/jest": "^27.4.1",
-    "@types/node": "^17.0.23",
+    "@types/cli-progress": "^3.11.0",
     "@types/tsc-watch": "^4.2.0",
-    "jest": "^27.5.1",
-    "prettier": "^2.6.1",
-    "ts-jest": "^27.1.4",
-    "ts-loader": "^9.2.8",
-    "ts-node": "^10.7.0",
-    "tsconfig-paths": "^3.14.1",
-    "typescript": "^4.6.3"
+    "@types/uuid": "^8.3.4",
+    "rxjs": "^7.5.6"
+  },
+  "peerDependencies": {
+    "rxjs": "^7.5.6"
   },
-  "engines": {
-    "node": ">= 14.18.1"
+  "scripts": {
+    "build": "tsc",
+    "test": "jest"
   }
 }

package/src/adapter/adapter-aggregate.ts

@@ -1,4 +1,4 @@
-import { Candle, InstrumentSelector, Order } from '../domain';
+import { InstrumentSelector, Ohlc, Order } from '../domain';
 import { Logger, timestamp } from '../shared';
 import { Cache } from '../storage';
 import { Store } from '../store';
@@ -18,7 +18,7 @@ export class AdapterAggregate {
     private readonly timeProvider: AdapterTimeProvider,
     private readonly store: Store,
     private readonly cache: Cache
-  ) {}
+  ) { }
 
   /**
    * Returns adapter by name.
@@ -45,8 +45,8 @@ export class AdapterAggregate {
       try {
         await adapter.awake();
         await adapter.account();
-      } catch (e) {
-        Logger.error(e);
+      } catch (error) {
+        Logger.error(adapter.name, error);
       }
 
       this.adapter[adapter.name] = adapter;
@@ -56,12 +56,12 @@ export class AdapterAggregate {
   /**
    * Disposes all adapters.
    */
-  async dispose(): Promise<any> {
+  async dispose(): Promise<void> {
     for (const adapter of Object.values(this.adapter)) {
       try {
         await adapter.dispose();
-      } catch (e) {
-        Logger.error(e);
+      } catch (error) {
+        Logger.error(adapter.name, error);
       }
     }
   }
@@ -81,13 +81,15 @@ export class AdapterAggregate {
       }
 
       return aggregate;
-    }, {});
+    }, {} as Record<string, InstrumentSelector[]>);
 
     for (const adapterName in grouped) {
       try {
         await this.get(adapterName).subscribe(grouped[adapterName]);
-      } catch (e) {
-        Logger.error(e);
+      } catch (error) {
+        Logger.error(adapterName, error);
+
+        throw error;
       }
     }
   }
@@ -97,10 +99,19 @@ export class AdapterAggregate {
    * @param order an order to open.
    */
   async open(order: Order): Promise<void> {
+    const { adapterName } = order.instrument.base;
+
+    Logger.debug(
+      adapterName,
+      `opening a new order on ${order.instrument.id} as ${order.id}`
+    );
+
     try {
-      await this.get(order.instrument.base.adapterName).open(order);
-    } catch (e) {
-      Logger.error(e);
+      await this.get(adapterName).open(order);
+    } catch (error) {
+      Logger.error(adapterName, error);
+
+      throw error;
     }
   }
 
@@ -108,10 +119,16 @@ export class AdapterAggregate {
    * Cancels specific order.
    */
   cancel(order: Order): Promise<void> {
+    const { adapterName } = order.instrument.base;
+
+    Logger.debug(adapterName, `canceling a ${order.id} order`);
+
     try {
-      return this.get(order.instrument.base.adapterName).cancel(order);
-    } catch (e) {
-      Logger.error(e);
+      return this.get(adapterName).cancel(order);
+    } catch (error) {
+      Logger.error(adapterName, error);
+
+      throw error;
     }
   }
 
@@ -123,11 +140,13 @@ export class AdapterAggregate {
     instrument: InstrumentSelector,
     timeframe: number,
     length: number
-  ): Promise<Candle[]> {
+  ): Promise<Ohlc[]> {
     try {
       return this.get(instrument.base.adapterName).history(instrument, timeframe, length);
-    } catch (e) {
-      Logger.error(e);
+    } catch (error) {
+      Logger.error(instrument.base.adapterName, error);
+
+      throw error;
     }
   }
 
@@ -143,8 +162,10 @@ export class AdapterAggregate {
   ): Promise<void> {
     try {
       return this.get(instrument.base.adapterName).feed(instrument, from, to, callback);
-    } catch (e) {
-      Logger.error(e);
+    } catch (error) {
+      Logger.error(instrument.base.adapterName, error);
+
+      throw error;
     }
   }
 }

package/src/adapter/adapter.ts

@@ -1,4 +1,4 @@
-import { Candle, InstrumentSelector, Order } from '../domain';
+import { Ohlc, InstrumentSelector, Order } from '../domain';
 import { now, timestamp } from '../shared';
 import { Cache, StorageEvent } from '../storage';
 import { Store } from '../store';
@@ -32,7 +32,7 @@ export abstract class Adapter {
     return this.timeProvider.timestamp();
   }
 
-  constructor(private readonly timeProvider: AdapterTimeProvider) {}
+  constructor(private readonly timeProvider: AdapterTimeProvider) { }
 
   /**
    * Setup an adapter.
@@ -70,7 +70,7 @@ export abstract class Adapter {
     instrument: InstrumentSelector,
     timeframe: number,
     length: number
-  ): Promise<Candle[]>;
+  ): Promise<Ohlc[]>;
 
   abstract feed(
     instrument: InstrumentSelector,

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

@@ -1,4 +1,4 @@
-import { Candle, InstrumentSelector, Order } from '../../domain';
+import { InstrumentSelector, Ohlc, Order } from '../../domain';
 import { timestamp } from '../../shared';
 import { InstrumentSubscriptionEvent, Store } from '../../store';
 import { Adapter } from '..';
@@ -53,8 +53,6 @@ export class BacktesterAdapter extends Adapter {
         it => new InstrumentSubscriptionEvent(this.timestamp(), it, true)
       )
     );
-
-    this.streamer.tryContinue();
   }
 
   account(): Promise<void> {
@@ -73,7 +71,7 @@ export class BacktesterAdapter extends Adapter {
     instrument: InstrumentSelector,
     timeframe: number,
     length: number
-  ): Promise<Candle[]> {
+  ): Promise<Ohlc[]> {
     this.streamer.stop();
 
     const response = await this.decoratedAdapter.history(instrument, timeframe, length);

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

@@ -14,7 +14,7 @@ export class BacktesterCursor {
 
   constructor(readonly instrument: InstrumentSelector, private readonly feed: Feed) {}
 
-  peek(): StorageEvent {
+  peek(): StorageEvent | undefined {
     if (!this.page) {
       return undefined;
     }

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

@@ -1,4 +1,4 @@
-import { Asset, Instrument } from '../../domain';
+import { Asset, Commission, Instrument } from '../../domain';
 import { d } from '../../shared';
 import { Feed, InMemoryStorage } from '../../storage';
 import { Store, TradePatchEvent } from '../../store';
@@ -6,9 +6,11 @@ import { BacktesterStreamer } from './backtester-streamer';
 
 describe('BacktesterStreamer', () => {
   const instrument = new Instrument(
+    0,
     new Asset('btc', 'binance', 8),
     new Asset('usdt', 'binance', 2),
-    'binance:btc-usdt'
+    'binance:btc-usdt',
+    Commission.Zero
   );
 
   test('should repeat specific events', done => {
@@ -27,7 +29,7 @@ describe('BacktesterStreamer', () => {
       },
       {
         onBacktestCompleted: () => {
-          const trade = store.snapshot.trade.get(instrument.id);
+          const trade = store.snapshot.trade.get(instrument.id) ?? fail();
 
           expect(trade.timestamp).toEqual(8);
           expect(trade.rate).toEqual(d(8));

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

@@ -4,6 +4,7 @@ import { Feed } from '../../storage';
 import { Store } from '../../store';
 import { AdapterTimeProvider } from '../adapter';
 import { BacktesterCursor } from './backtester-cursor';
+import { invalidEventSequenceError, missingPeriodParametersError } from './error';
 
 /**
  * Listen to backtest session events.
@@ -40,7 +41,7 @@ export class BacktesterStreamer {
     private readonly listener?: BacktesterListener
   ) {
     if (period.from == undefined || period.to == undefined) {
-      throw new Error('invalid backtest options, please provide from and to period.');
+      throw missingPeriodParametersError();
     }
 
     this.timestamp = period.from;
@@ -86,7 +87,7 @@ export class BacktesterStreamer {
     }
 
     if (this.sequence == 0) {
-      if (this.listener.onBacktestStarted) {
+      if (this.listener?.onBacktestStarted) {
         this.listener.onBacktestStarted(this);
       }
     }
@@ -94,7 +95,7 @@ export class BacktesterStreamer {
     const next = async () => {
       if (await this.processNext()) {
         if (this.sequence % this.sequenceUpdateBatch == 0) {
-          if (this.listener.onBacktestUpdated) {
+          if (this.listener?.onBacktestUpdated) {
             this.listener.onBacktestUpdated(this);
           }
         }
@@ -103,7 +104,7 @@ export class BacktesterStreamer {
           setImmediate(next);
         }
       } else {
-        if (this.listener.onBacktestCompleted) {
+        if (this.listener?.onBacktestCompleted) {
           this.listener.onBacktestCompleted(this);
         }
       }
@@ -120,19 +121,26 @@ export class BacktesterStreamer {
 
     const event = cursor.peek();
 
+    if (!event) {
+      return false;
+    }
+
     this.timestamp = event.timestamp;
     this.sequence++;
 
     this.store.dispatch(event);
 
     if (cursor.dequeue().timestamp != event.timestamp) {
-      throw new Error('invalid event to consume');
+      throw invalidEventSequenceError();
     }
 
     return true;
   }
 
-  private async current(from: timestamp, to: timestamp): Promise<BacktesterCursor> {
+  private async current(
+    from: timestamp,
+    to: timestamp
+  ): Promise<BacktesterCursor | undefined> {
     for (const cursor of Object.values(this.cursor)) {
       if (cursor.size == 0 && !cursor.completed) {
         await cursor.fetchNextPage(from, to);
@@ -140,8 +148,8 @@ export class BacktesterStreamer {
     }
 
     return Object.values(this.cursor)
-      .filter(it => it.peek() != undefined)
-      .sort((lhs, rhs) => lhs.peek().timestamp - rhs.peek().timestamp)
+      .filter(it => it !== undefined)
+      .sort((lhs, rhs) => (lhs?.peek()?.timestamp ?? 0) - (rhs?.peek()?.timestamp ?? 0))
       .find(() => true);
   }
 }

package/src/adapter/backtester/error.ts

@@ -0,0 +1,7 @@
+export function missingPeriodParametersError() {
+  return new Error('invalid backtest options, please provide from and to period.');
+}
+
+export function invalidEventSequenceError() {
+  return new Error('invalid event to consume');
+}

package/src/adapter/error.ts

@@ -4,6 +4,10 @@ export function adapterNotFoundError(adapterName: string) {
   );
 }
 
+export function noPaperEngineProvidedError() {
+  return new Error('No paper engine provided.');
+}
+
 export function backtestPageNotEmpty() {
   return new Error('Backtest page is not empty');
 }

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

@@ -1,4 +1,10 @@
-import { Asset, commissionPercentOf, Instrument, Order } from '../../../domain';
+import {
+  Asset,
+  Commission,
+  commissionPercentOf,
+  Instrument,
+  Order
+} from '../../../domain';
 import { d, now } from '../../../shared';
 import {
   BalancePatchEvent,
@@ -11,9 +17,11 @@ 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({
@@ -24,7 +32,7 @@ describe('PaperEngine', () => {
   test('should open a new buy market order', () => {
     const store = new Store();
     const engine = new PaperEngine(store);
-    const order = Order.market(instrument, d(1.0));
+    const order = new Order(0, '1', instrument, d(1.0), 0);
 
     store.dispatch(
       new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
@@ -34,16 +42,19 @@ describe('PaperEngine', () => {
 
     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(d.Zero);
-    expect(store.snapshot.balance.get(instrument.quote.id).locked).toEqual(d(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, d(-0.6));
+    const order = new Order(0, '1', instrument, d(-0.6), 0);
 
     store.dispatch(
       new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
@@ -53,16 +64,19 @@ describe('PaperEngine', () => {
 
     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(d(0.4));
-    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(d(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, d(-0.6), d(100));
+    const order = new Order(0, '1', instrument, d(-0.6), 0, d(100));
 
     store.dispatch(
       new InstrumentPatchEvent(now(), instrument.base, instrument.quote, commission, ''),
@@ -73,12 +87,13 @@ describe('PaperEngine', () => {
 
     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(store.snapshot.balance.get(instrument.base.id).free).toEqual(d(0.4));
-    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(d(0.6));
+    expect(pendingOrder.state).toEqual('PENDING');
+    expect(baseBalance.free).toEqual(d(0.4));
+    expect(baseBalance.locked).toEqual(d(0.6));
 
     store.dispatch(
       new OrderbookPatchEvent(
@@ -89,11 +104,13 @@ describe('PaperEngine', () => {
       )
     );
 
+    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(d(0.4));
-    expect(store.snapshot.balance.get(instrument.base.id).locked).toEqual(d.Zero);
-    expect(store.snapshot.balance.get(instrument.quote.id).free).toEqual(d(1060.53));
-    expect(store.snapshot.balance.get(instrument.quote.id).locked).toEqual(d.Zero);
+    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

@@ -14,6 +14,7 @@ import {
   OrderRejectedEvent,
   Store
 } from '../../../store';
+import { instrumentNotSupportedError } from '../../../store/error';
 
 export class PaperEngine {
   constructor(private readonly store: Store) {
@@ -60,55 +61,63 @@ 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.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.type == 'MARKET') {
-          if (it.quantity.greaterThan(0)) {
-            this.completeOrder(it, orderbook.asks.rate);
-          } else if (it.quantity.lessThan(0)) {
-            this.completeOrder(it, orderbook.bids.rate);
-          }
+    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.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 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: 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: d.Zero,
       quote: d.Zero