@quantform/core 0.5.15 → 0.6.4

package/src/domain/asset.ts

@@ -1,10 +1,10 @@
-import { ceil, fixed, floor } from '../shared/decimals';
+import { d, decimal } from './../shared/decimals';
 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;
@@ -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.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,112 +1,116 @@
+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(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);
+    const sut = new Balance(1, 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);
+    const sut = new Balance(0, 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);
+    const sut = new Balance(0, 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);
+    const sut = new Balance(0, 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();
   });
 
   test('should lock specific amount of available balance', () => {
-    const sut = new Balance(asset);
+    const sut = new Balance(0, 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);
+    const sut = new Balance(0, 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();
   });
 
-  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(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(0, '1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
 
-    position.calculateEstimatedUnrealizedPnL(2576.44);
+    position.calculateEstimatedUnrealizedPnL(d(2576.44));
 
-    const sut = new Balance(asset);
+    const sut = new Balance(0, 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 } from '../shared';
 import { Asset } from './';
 import { Component } from './component';
 import { insufficientFundsError, invalidArgumentError } from './error';
@@ -10,23 +10,22 @@ import { Position, PositionMode } from './position';
 export class Balance implements Component {
   id: string;
   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 +33,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());
   }
 
   /**
@@ -46,19 +44,19 @@ 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;
   }
 
-  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 +66,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 +76,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 +93,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 +102,23 @@ 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.add(
+          mode && mode != position.mode
+            ? d.Zero
+            : position.estimatedUnrealizedPnL ?? d.Zero
+        ),
+      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

@@ -0,0 +1,126 @@
+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: 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 = [
+      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({
+      next: it => {
+        expect(it).toEqual(output.pop());
+        if (output.length === 0) {
+          done();
+        }
+      }
+    });
+  });
+});
+
+describe('candleCompleted', () => {
+  test('should aggregate and pipe distinct completed candles', done => {
+    const input$ = from([
+      { 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$
+      .pipe(
+        candle(5, it => it.rate),
+        candleCompleted()
+      )
+      .subscribe({
+        next: it => {
+          expect(it).toEqual(new Candle(0, d(1), d(3), d.Zero, d.Zero));
+          done();
+        }
+      });
+  });
+});
+
+describe('mergeCandle', () => {
+  test('should pipe and merge candle from history', done => {
+    const history$ = from([
+      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: d(5) },
+      { timestamp: 4, rate: d(3) },
+      { timestamp: 5, rate: d(4) }
+    ]);
+
+    const output = [
+      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({
+      next: it => {
+        expect(it).toEqual(output.pop());
+        if (output.length === 0) {
+          done();
+        }
+      }
+    });
+  });
+
+  test('should pipe and not merge candle from history', done => {
+    const history$ = from([
+      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: d(5) },
+      { timestamp: 5, rate: d(3) },
+      { timestamp: 6, rate: d(4) }
+    ]);
+
+    const output = [
+      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({
+      next: it => {
+        expect(it).toEqual(output.pop());
+        if (output.length === 0) {
+          done();
+        }
+      }
+    });
+  });
+});

package/src/domain/{candle.operator.ts → candle-operator.ts}

@@ -5,15 +5,22 @@ import {
   map,
   mergeMap,
   Observable,
+  OperatorFunction,
   share,
   skipLast,
   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 | undefined,
+  timeframe: number,
+  value: decimal,
+  timestamp: number
+) {
   const frame = tf(timestamp, timeframe);
 
   if (!candle) {
@@ -22,6 +29,7 @@ function aggregate(candle: Candle, timeframe: number, value: number, timestamp:
 
   if (candle.timestamp === frame) {
     candle.apply(value);
+    return undefined;
   } else {
     return new Candle(frame, candle.close, value, value, value);
   }
@@ -29,8 +37,8 @@ function aggregate(candle: Candle, timeframe: number, value: number, timestamp:
 
 export function candle<T extends { timestamp: number }>(
   timeframe: number,
-  fn: (x: T) => number,
-  candleToStartWith: Candle = undefined
+  fn: (x: T) => decimal,
+  candleToStartWith?: Candle
 ) {
   return function (source: Observable<T>): Observable<Candle> {
     let candle = candleToStartWith;
@@ -44,7 +52,12 @@ export function candle<T extends { timestamp: number }>(
 
           if (candleToStartWith && candleToStartWith.timestamp < newCandle.timestamp) {
             candleToStartWith = undefined;
-            return [prevCandle, candle];
+
+            if (prevCandle) {
+              return [prevCandle, candle];
+            }
+
+            return [candle];
           }
         }
 
@@ -52,7 +65,11 @@ export function candle<T extends { timestamp: number }>(
           candleToStartWith = undefined;
         }
 
-        return [candle];
+        if (candle) {
+          return [candle];
+        }
+
+        return [];
       }),
       mergeMap(it => it),
       share()
@@ -62,7 +79,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> {
@@ -100,7 +117,7 @@ export function candleCompleted(): (source: Observable<Candle>) => Observable<Ca
           return undefined;
         }
       }),
-      filter(it => !!it),
+      filter(it => it !== undefined) as OperatorFunction<Candle | undefined, Candle>,
       share()
     );
 }

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;
   }
 }