@quantform/core 0.5.15 → 0.5.23

package/src/cli/pull.ts

@@ -49,18 +49,19 @@ export default async function (name: string, instrument: string, options: any) {
 
   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/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');
   });
 

package/src/domain/asset.ts

@@ -1,4 +1,4 @@
-import { ceil, fixed, floor } from '../shared/decimals';
+import { d, decimal } from './../shared/decimals';
 import { invalidArgumentError, invalidAssetSelectorError } from './error';
 
 export const AssetSelectorSeparator = ':';
@@ -51,7 +51,7 @@ export function assetOf(selector: string): AssetSelector {
  * For example, you can combine two trading assets to create a trading instrument.
  */
 export class Asset extends AssetSelector {
-  readonly tickSize: number;
+  readonly tickSize: decimal;
 
   constructor(name: string, adapterName: string, public readonly scale: number) {
     super(name, adapterName);
@@ -60,27 +60,20 @@ export class Asset extends AssetSelector {
       throw invalidArgumentError(scale);
     }
 
-    this.tickSize = 1.0 / Math.pow(10, this.scale);
-  }
-
-  /**
-   * Trims a number to the asset precision.
-   */
-  fixed(number: number): number {
-    return fixed(number, this.scale);
+    this.tickSize = d(1.0).div(Math.pow(10, this.scale));
   }
 
   /**
    * Rounds down a number to the asset precision.
    */
-  floor(number: number): number {
-    return floor(number, this.scale);
+  floor(number: decimal): decimal {
+    return number.toFloor(this.scale);
   }
 
   /**
    * Rounds up a number to the asset precision.
    */
-  ceil(number: number): number {
-    return ceil(number, this.scale);
+  ceil(number: decimal): decimal {
+    return number.toCeil(this.scale);
   }
 }

package/src/domain/balance.spec.ts

@@ -1,3 +1,4 @@
+import { d } from '../shared';
 import { Asset } from './asset';
 import { Balance } from './balance';
 import { Instrument } from './instrument';
@@ -15,50 +16,50 @@ describe('Balance', () => {
     const sut = new Balance(asset);
 
     expect(sut.asset.id).toEqual('xyz:abc');
-    expect(sut.free).toEqual(0);
-    expect(sut.locked).toEqual(0);
+    expect(sut.free).toEqual(d.Zero);
+    expect(sut.locked).toEqual(d.Zero);
     expect(Object.keys(sut.position).length).toEqual(0);
   });
 
   test('should construct balance', () => {
     const sut = new Balance(asset);
 
-    sut.set(100, 50);
+    sut.set(d(100), d(50));
 
     expect(sut.asset.id).toEqual('xyz:abc');
-    expect(sut.free).toEqual(100);
-    expect(sut.locked).toEqual(50);
-    expect(sut.total).toEqual(150);
+    expect(sut.free).toEqual(d(100));
+    expect(sut.locked).toEqual(d(50));
+    expect(sut.total).toEqual(d(150));
     expect(Object.keys(sut.position).length).toEqual(0);
   });
 
   test('should account positive amount', () => {
     const sut = new Balance(asset);
 
-    sut.set(100, 0);
-    sut.account(10);
+    sut.set(d(100), d.Zero);
+    sut.account(d(10));
 
-    expect(sut.free).toEqual(110);
-    expect(sut.locked).toEqual(0);
-    expect(sut.total).toEqual(110);
+    expect(sut.free).toEqual(d(110));
+    expect(sut.locked).toEqual(d.Zero);
+    expect(sut.total).toEqual(d(110));
   });
 
   test('should account negative amount', () => {
     const sut = new Balance(asset);
 
-    sut.set(100, 0);
-    sut.account(-10);
+    sut.set(d(100), d.Zero);
+    sut.account(d(-10));
 
-    expect(sut.free).toEqual(90);
-    expect(sut.locked).toEqual(0);
-    expect(sut.total).toEqual(90);
+    expect(sut.free).toEqual(d(90));
+    expect(sut.locked).toEqual(d.Zero);
+    expect(sut.total).toEqual(d(90));
   });
 
   test('should throw for insufficient balance account amount', () => {
     const sut = new Balance(asset);
 
-    sut.set(100, 0);
-    const fn = () => sut.account(-120);
+    sut.set(d(100), d.Zero);
+    const fn = () => sut.account(d(-120));
 
     expect(fn).toThrowError();
   });
@@ -66,19 +67,19 @@ describe('Balance', () => {
   test('should lock specific amount of available balance', () => {
     const sut = new Balance(asset);
 
-    sut.set(100, 0);
-    sut.lock('key', 10);
+    sut.set(d(100), d.Zero);
+    sut.lock('key', d(10));
 
-    expect(sut.free).toEqual(90);
-    expect(sut.locked).toEqual(10);
-    expect(sut.total).toEqual(100);
+    expect(sut.free).toEqual(d(90));
+    expect(sut.locked).toEqual(d(10));
+    expect(sut.total).toEqual(d(100));
   });
 
   test('should throw for lock insufficient amount of available balance', () => {
     const sut = new Balance(asset);
 
-    sut.set(30, 50);
-    const fn = () => sut.lock('key', 100);
+    sut.set(d(30), d(50));
+    const fn = () => sut.lock('key', d(100));
 
     expect(fn).toThrowError();
   });
@@ -86,27 +87,27 @@ describe('Balance', () => {
   test('should lock an unlock specific amount of available balance', () => {
     const sut = new Balance(asset);
 
-    sut.set(100, 0);
-    sut.lock('key', 40);
+    sut.set(d(100), d.Zero);
+    sut.lock('key', d(40));
     sut.tryUnlock('key');
 
-    expect(sut.free).toEqual(100);
-    expect(sut.locked).toEqual(0);
-    expect(sut.total).toEqual(100);
+    expect(sut.free).toEqual(d(100));
+    expect(sut.locked).toEqual(d.Zero);
+    expect(sut.total).toEqual(d(100));
   });
 
   test('should return correct estimated unrealized pnl', () => {
-    const position = new Position('1', instrument, 'CROSS', 2511.81, 10.31, 20);
+    const position = new Position('1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
 
-    position.calculateEstimatedUnrealizedPnL(2576.44);
+    position.calculateEstimatedUnrealizedPnL(d(2576.44));
 
     const sut = new Balance(asset);
 
-    sut.set(100, 0);
+    sut.set(d(100), d.Zero);
     sut.position['1'] = position;
 
-    expect(sut.getEstimatedUnrealizedPnL()).toEqual(0.2652);
-    expect(sut.free).toEqual(100 + 0.2652);
-    expect(sut.total).toEqual(100 + 0.2652);
+    expect(sut.getEstimatedUnrealizedPnL()).toEqual(d(0.2652));
+    expect(sut.free).toEqual(d(100).add(d(0.2652)));
+    expect(sut.total).toEqual(d(100).add(d(0.2652)));
   });
 });

package/src/domain/balance.ts

@@ -1,4 +1,4 @@
-import { timestamp } from '../shared';
+import { d, decimal, timestamp } from '../shared';
 import { Asset } from './';
 import { Component } from './component';
 import { insufficientFundsError, invalidArgumentError } from './error';
@@ -12,21 +12,21 @@ export class Balance implements Component {
   kind = 'balance';
   timestamp: timestamp;
 
-  private locker: Record<string, number> = {};
-  private available = 0;
-  private unavailable = 0;
+  private locker: Record<string, decimal> = {};
+  private available = d.Zero;
+  private unavailable = d.Zero;
 
   /**
    * Returns available amount to trade.
    */
-  get free(): number {
-    return this.asset.fixed(this.available) + this.getEstimatedUnrealizedPnL('CROSS');
+  get free(): decimal {
+    return this.asset.floor(this.available).add(this.getEstimatedUnrealizedPnL('CROSS'));
   }
 
   /**
    * Return locked amount for order.
    */
-  get locked(): number {
+  get locked(): decimal {
     return this.unavailable;
   }
 
@@ -34,11 +34,10 @@ export class Balance implements Component {
    * Return total amount of asset in wallet.
    * Represents a sum of free, locked and opened positions.
    */
-  get total(): number {
-    return (
-      this.asset.fixed(this.available + this.unavailable) +
-      this.getEstimatedUnrealizedPnL()
-    );
+  get total(): decimal {
+    return this.asset
+      .floor(this.available.add(this.unavailable))
+      .add(this.getEstimatedUnrealizedPnL());
   }
 
   /**
@@ -50,15 +49,15 @@ export class Balance implements Component {
     this.id = asset.id;
   }
 
-  account(amount: number) {
-    if (this.available + amount < 0) {
+  account(amount: decimal) {
+    if (this.available.add(amount).lessThan(0)) {
       throw insufficientFundsError(this.id, amount, this.available);
     }
 
-    this.available += amount;
+    this.available = this.available.add(amount);
   }
 
-  set(free: number, locked: number) {
+  set(free: decimal, locked: decimal) {
     this.available = free;
     this.unavailable = locked;
     this.locker = {};
@@ -68,8 +67,8 @@ export class Balance implements Component {
    * Lock specific amount of asset.
    * If you place new pending order, you will lock your balance to fund order.
    */
-  lock(id: string, amount: number) {
-    if (this.available < amount) {
+  lock(id: string, amount: decimal) {
+    if (this.available.lessThan(amount)) {
       throw insufficientFundsError(this.id, amount, this.available);
     }
 
@@ -78,8 +77,8 @@ export class Balance implements Component {
     }
 
     this.locker[id] = amount;
-    this.available -= amount;
-    this.unavailable += amount;
+    this.available = this.available.minus(amount);
+    this.unavailable = this.unavailable.plus(amount);
   }
 
   tryUnlock(id: string): boolean {
@@ -95,8 +94,8 @@ export class Balance implements Component {
       throw insufficientFundsError(this.id, amount, this.unavailable);
     }
 
-    this.available += amount;
-    this.unavailable -= amount;
+    this.available = this.available.add(amount);
+    this.unavailable = this.unavailable.minus(amount);
 
     return true;
   }
@@ -104,20 +103,21 @@ export class Balance implements Component {
   /**
    * Returns unrealized profit and loss for all positions backed by this balance.
    */
-  getEstimatedUnrealizedPnL(mode?: PositionMode) {
+  getEstimatedUnrealizedPnL(mode?: PositionMode): decimal {
     return Object.values(this.position).reduce(
       (aggregate, position) =>
-        (aggregate +=
-          mode && mode != position.mode ? 0 : position.estimatedUnrealizedPnL),
-      0
+        (aggregate = aggregate.add(
+          mode && mode != position.mode ? 0 : position.estimatedUnrealizedPnL
+        )),
+      d.Zero
     );
   }
 
-  getEstimatedMargin(mode?: PositionMode): number {
+  getEstimatedMargin(mode?: PositionMode): decimal {
     return Object.values(this.position).reduce(
       (aggregate, position) =>
-        (aggregate += mode && mode != position.mode ? 0 : position.margin),
-      0
+        (aggregate = aggregate.add(mode && mode != position.mode ? 0 : position.margin)),
+      d.Zero
     );
   }
 

package/src/domain/candle.operator.spec.ts

@@ -1,26 +1,27 @@
 import { from } from 'rxjs';
 
+import { d } from '../shared';
 import { Candle } from './candle';
 import { candle, candleCompleted, mergeCandle } from './candle.operator';
 
 describe('candle', () => {
   test('should aggregate and pipe candle updates', done => {
     const input$ = from([
-      { timestamp: 1, rate: 1 },
-      { timestamp: 2, rate: 2 },
-      { timestamp: 3, rate: 3 },
-      { timestamp: 4, rate: 0 },
-      { timestamp: 5, rate: 7 },
-      { timestamp: 6, rate: 8 }
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d.Zero },
+      { timestamp: 5, rate: d(7) },
+      { timestamp: 6, rate: d(8) }
     ]);
 
     const output = [
-      { timestamp: 0, open: 1, high: 1, low: 1, close: 1 },
-      { timestamp: 0, open: 1, high: 2, low: 1, close: 2 },
-      { timestamp: 0, open: 1, high: 3, low: 1, close: 3 },
-      { timestamp: 0, open: 1, high: 3, low: 0, close: 0 },
-      { timestamp: 5, open: 0, high: 7, low: 7, close: 7 },
-      { timestamp: 5, open: 0, high: 8, low: 7, close: 8 }
+      new Candle(0, d(1), d(1), d(1), d(1)),
+      new Candle(0, d(1), d(2), d(1), d(2)),
+      new Candle(0, d(1), d(3), d(1), d(3)),
+      new Candle(0, d(1), d(3), d.Zero, d.Zero),
+      new Candle(5, d.Zero, d(7), d(7), d(7)),
+      new Candle(5, d.Zero, d(8), d(7), d(8))
     ].reverse();
 
     input$.pipe(candle(5, it => it.rate)).subscribe({
@@ -37,12 +38,12 @@ describe('candle', () => {
 describe('candleCompleted', () => {
   test('should aggregate and pipe distinct completed candles', done => {
     const input$ = from([
-      { timestamp: 1, rate: 1 },
-      { timestamp: 2, rate: 2 },
-      { timestamp: 3, rate: 3 },
-      { timestamp: 4, rate: 0 },
-      { timestamp: 5, rate: 7 },
-      { timestamp: 6, rate: 8 }
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d.Zero },
+      { timestamp: 5, rate: d(7) },
+      { timestamp: 6, rate: d(8) }
     ]);
 
     input$
@@ -52,7 +53,7 @@ describe('candleCompleted', () => {
       )
       .subscribe({
         next: it => {
-          expect(it).toEqual({ timestamp: 0, open: 1, high: 3, low: 0, close: 0 });
+          expect(it).toEqual(new Candle(0, d(1), d(3), d.Zero, d.Zero));
           done();
         }
       });
@@ -62,23 +63,23 @@ describe('candleCompleted', () => {
 describe('mergeCandle', () => {
   test('should pipe and merge candle from history', done => {
     const history$ = from([
-      new Candle(1, 1, 1.5, 0.5, 2),
-      new Candle(2, 2, 2.5, 1.5, 3),
-      new Candle(3, 3, 3.5, 2.5, 4)
+      new Candle(1, d(1), d(1.5), d(0.5), d(2)),
+      new Candle(2, d(2), d(2.5), d(1.5), d(3)),
+      new Candle(3, d(3), d(3.5), d(2.5), d(4))
     ]);
 
     const input$ = from([
-      { timestamp: 3, rate: 5 },
-      { timestamp: 4, rate: 3 },
-      { timestamp: 5, rate: 4 }
+      { timestamp: 3, rate: d(5) },
+      { timestamp: 4, rate: d(3) },
+      { timestamp: 5, rate: d(4) }
     ]);
 
     const output = [
-      { timestamp: 1, open: 1, high: 1.5, low: 0.5, close: 2 },
-      { timestamp: 2, open: 2, high: 2.5, low: 1.5, close: 3 },
-      { timestamp: 3, open: 3, high: 5, low: 2.5, close: 5 },
-      { timestamp: 4, open: 5, high: 3, low: 3, close: 3 },
-      { timestamp: 5, open: 3, high: 4, low: 4, close: 4 }
+      new Candle(1, d(1), d(1.5), d(0.5), d(2)),
+      new Candle(2, d(2), d(2.5), d(1.5), d(3)),
+      new Candle(3, d(3), d(5), d(2.5), d(5)),
+      new Candle(4, d(5), d(3), d(3), d(3)),
+      new Candle(5, d(3), d(4), d(4), d(4))
     ].reverse();
 
     input$.pipe(mergeCandle(1, it => it.rate, history$)).subscribe({
@@ -93,24 +94,24 @@ describe('mergeCandle', () => {
 
   test('should pipe and not merge candle from history', done => {
     const history$ = from([
-      new Candle(1, 1, 1.5, 0.5, 2),
-      new Candle(2, 2, 2.5, 1.5, 3),
-      new Candle(3, 3, 3.5, 2.5, 4)
+      new Candle(1, d(1), d(1.5), d(0.5), d(2)),
+      new Candle(2, d(2), d(2.5), d(1.5), d(3)),
+      new Candle(3, d(3), d(3.5), d(2.5), d(4))
     ]);
 
     const input$ = from([
-      { timestamp: 4, rate: 5 },
-      { timestamp: 5, rate: 3 },
-      { timestamp: 6, rate: 4 }
+      { timestamp: 4, rate: d(5) },
+      { timestamp: 5, rate: d(3) },
+      { timestamp: 6, rate: d(4) }
     ]);
 
     const output = [
-      { timestamp: 1, open: 1, high: 1.5, low: 0.5, close: 2 },
-      { timestamp: 2, open: 2, high: 2.5, low: 1.5, close: 3 },
-      { timestamp: 3, open: 3, high: 3.5, low: 2.5, close: 4 },
-      { timestamp: 4, open: 4, high: 5, low: 5, close: 5 },
-      { timestamp: 5, open: 5, high: 3, low: 3, close: 3 },
-      { timestamp: 6, open: 3, high: 4, low: 4, close: 4 }
+      new Candle(1, d(1), d(1.5), d(0.5), d(2)),
+      new Candle(2, d(2), d(2.5), d(1.5), d(3)),
+      new Candle(3, d(3), d(3.5), d(2.5), d(4)),
+      new Candle(4, d(4), d(5), d(5), d(5)),
+      new Candle(5, d(5), d(3), d(3), d(3)),
+      new Candle(6, d(3), d(4), d(4), d(4))
     ].reverse();
 
     input$.pipe(mergeCandle(1, it => it.rate, history$)).subscribe({

package/src/domain/candle.operator.ts

@@ -10,10 +10,11 @@ import {
   switchMap
 } from 'rxjs';
 
+import { decimal } from '../shared';
 import { Candle } from './candle';
 import { tf } from './timeframe';
 
-function aggregate(candle: Candle, timeframe: number, value: number, timestamp: number) {
+function aggregate(candle: Candle, timeframe: number, value: decimal, timestamp: number) {
   const frame = tf(timestamp, timeframe);
 
   if (!candle) {
@@ -29,7 +30,7 @@ function aggregate(candle: Candle, timeframe: number, value: number, timestamp:
 
 export function candle<T extends { timestamp: number }>(
   timeframe: number,
-  fn: (x: T) => number,
+  fn: (x: T) => decimal,
   candleToStartWith: Candle = undefined
 ) {
   return function (source: Observable<T>): Observable<Candle> {
@@ -62,7 +63,7 @@ export function candle<T extends { timestamp: number }>(
 
 export function mergeCandle<T extends { timestamp: number }>(
   timeframe: number,
-  fn: (x: T) => number,
+  fn: (x: T) => decimal,
   history$: Observable<Candle>
 ) {
   return function (source$: Observable<T>): Observable<Candle> {

package/src/domain/candle.spec.ts

@@ -1,29 +1,30 @@
-import { now } from '../shared';
+import { d, now } from '../shared';
 import { Candle } from './candle';
 
 describe('Candle', () => {
   test('should construct a candle', () => {
     const timestamp = now();
 
-    const sut = new Candle(timestamp, 2, 4, 1, 3);
+    const sut = new Candle(timestamp, d(2), d(4), d(1), d(3));
 
     expect(sut.timestamp).toEqual(timestamp);
-    expect(sut.open).toEqual(2);
-    expect(sut.high).toEqual(4);
-    expect(sut.low).toEqual(1);
-    expect(sut.close).toEqual(3);
+    expect(sut.open).toEqual(d(2));
+    expect(sut.high).toEqual(d(4));
+    expect(sut.low).toEqual(d(1));
+    expect(sut.close).toEqual(d(3));
   });
 
   test('should modify a candle', () => {
     const timestamp = now();
 
-    const sut = new Candle(timestamp, 2, 4, 1, 3);
-    sut.apply(10);
+    const sut = new Candle(timestamp, d(2), d(4), d(1), d(3));
+
+    sut.apply(d(10));
 
     expect(sut.timestamp).toEqual(timestamp);
-    expect(sut.open).toEqual(2);
-    expect(sut.high).toEqual(10);
-    expect(sut.low).toEqual(1);
-    expect(sut.close).toEqual(10);
+    expect(sut.open).toEqual(d(2));
+    expect(sut.high).toEqual(d(10));
+    expect(sut.low).toEqual(d(1));
+    expect(sut.close).toEqual(d(10));
   });
 });

package/src/domain/candle.ts

@@ -1,18 +1,18 @@
-import { timestamp } from '../shared';
+import { decimal, timestamp } from '../shared';
 
 export class Candle {
   constructor(
     public timestamp: timestamp,
-    public open: number,
-    public high: number,
-    public low: number,
-    public close: number,
-    public volume?: number
+    public open: decimal,
+    public high: decimal,
+    public low: decimal,
+    public close: decimal,
+    public volume?: decimal
   ) {}
 
-  apply(value: number) {
-    this.high = Math.max(this.high, value);
-    this.low = Math.min(this.low, value);
+  apply(value: decimal) {
+    this.high = decimal.max(this.high, value);
+    this.low = decimal.min(this.low, value);
     this.close = value;
   }
 }

package/src/domain/commission.spec.ts

@@ -1,33 +1,34 @@
+import { d } from '../shared';
 import { commissionPercentOf } from './commission';
 
 describe('Commission', () => {
   test('should construct a Commission', () => {
     const sut = commissionPercentOf({
-      maker: 0.1,
-      taker: 0.2
+      maker: d(0.1),
+      taker: d(0.2)
     });
 
-    expect(sut.makerRate).toEqual(0.001);
-    expect(sut.takerRate).toEqual(0.002);
+    expect(sut.makerRate).toEqual(d(0.001));
+    expect(sut.takerRate).toEqual(d(0.002));
   });
 
   test('should calculate a maker fee', () => {
     const sut = commissionPercentOf({
-      maker: 0.1,
-      taker: 0.2
+      maker: d(0.1),
+      taker: d(0.2)
     });
 
-    expect(sut.calculateMakerFee(2000)).toEqual(2);
-    expect(sut.applyMakerFee(2000)).toEqual(1998);
+    expect(sut.calculateMakerFee(d(2000))).toEqual(d(2));
+    expect(sut.applyMakerFee(d(2000))).toEqual(d(1998));
   });
 
   test('should calculate a taker fee', () => {
     const sut = commissionPercentOf({
-      maker: 0.1,
-      taker: 0.2
+      maker: d(0.1),
+      taker: d(0.2)
     });
 
-    expect(sut.calculateTakerFee(2000)).toEqual(4);
-    expect(sut.applyTakerFee(2000)).toEqual(1996);
+    expect(sut.calculateTakerFee(d(2000))).toEqual(d(4));
+    expect(sut.applyTakerFee(d(2000))).toEqual(d(1996));
   });
 });