@quantform/core 0.5.15 → 0.5.23

package/src/domain/commission.ts

@@ -1,23 +1,25 @@
+import { decimal } from '../shared';
+
 export class Commission {
-  constructor(readonly makerRate: number, readonly takerRate: number) {}
+  constructor(readonly makerRate: decimal, readonly takerRate: decimal) {}
 
-  calculateMakerFee(value: number) {
-    return value * this.makerRate;
+  calculateMakerFee(value: decimal) {
+    return value.mul(this.makerRate);
   }
 
-  calculateTakerFee(value: number) {
-    return value * this.takerRate;
+  calculateTakerFee(value: decimal) {
+    return value.mul(this.takerRate);
   }
 
-  applyMakerFee(value: number): number {
-    return value - this.calculateMakerFee(value);
+  applyMakerFee(value: decimal): decimal {
+    return value.minus(this.calculateMakerFee(value));
   }
 
-  applyTakerFee(value: number): number {
-    return value - this.calculateTakerFee(value);
+  applyTakerFee(value: decimal): decimal {
+    return value.minus(this.calculateTakerFee(value));
   }
 }
 
-export function commissionPercentOf(fees: { maker: number; taker: number }) {
-  return new Commission(fees.maker / 100.0, fees.taker / 100.0);
+export function commissionPercentOf(fees: { maker: decimal; taker: decimal }) {
+  return new Commission(fees.maker.div(100.0), fees.taker.div(100.0));
 }

package/src/domain/error.ts

@@ -1,10 +1,12 @@
+import { decimal } from '../shared';
+
 export function insufficientFundsError(
   assetName: string,
-  requiredAmount: number,
-  availableAmount: number
+  requiredAmount: decimal,
+  availableAmount: decimal
 ) {
   return new Error(
-    `insufficient funds of ${assetName} has: ${availableAmount} requires: ${requiredAmount}`
+    `insufficient funds of ${assetName} has: ${availableAmount.toString()} requires: ${requiredAmount.toString()}`
   );
 }
 

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

@@ -1,5 +1,6 @@
 import { BehaviorSubject, map, Subject } from 'rxjs';
 
+import { d } from '../shared';
 import { InnerSet, State } from '../store';
 import { Asset } from './asset';
 import { Component } from './component';
@@ -15,12 +16,12 @@ const instrument = new Instrument(
 
 describe('order', () => {
   test('should pipe an order', done => {
-    new BehaviorSubject<Component>(Order.market(instrument, -100))
+    new BehaviorSubject<Component>(Order.market(instrument, d(-100)))
       .pipe(order(instrument))
       .subscribe({
         next: it => {
           expect(it.instrument).toEqual(instrument);
-          expect(it.quantity).toEqual(-100);
+          expect(it.quantity).toEqual(d(-100));
           done();
         }
       });
@@ -41,9 +42,9 @@ describe('positions', () => {
   beforeEach(() => {
     state = new State();
 
-    order1 = Order.market(instrument, -100);
-    order2 = Order.limit(instrument, 100, 10);
-    order3 = Order.market(instrument, 100);
+    order1 = Order.market(instrument, d(-100));
+    order2 = Order.limit(instrument, d(100), d(10));
+    order3 = Order.market(instrument, d(100));
 
     state.order.upsert(new InnerSet<Order>(instrument.id, [order1, order2, order3]));
   });

package/src/domain/order.spec.ts

@@ -1,3 +1,4 @@
+import { d } from '../shared';
 import { Asset } from './asset';
 import { Instrument } from './instrument';
 import { Order } from './order';
@@ -10,34 +11,34 @@ describe('Order', () => {
   );
 
   test('should construct a market buy order', () => {
-    const sut = Order.market(instrument, 100);
+    const sut = Order.market(instrument, d(100));
 
-    expect(sut.quantity).toEqual(100);
+    expect(sut.quantity).toEqual(d(100));
     expect(sut.rate).toEqual(undefined);
     expect(sut.type).toEqual('MARKET');
   });
 
   test('should construct a market sell order', () => {
-    const sut = Order.market(instrument, -100);
+    const sut = Order.market(instrument, d(-100));
 
-    expect(sut.quantity).toEqual(-100);
+    expect(sut.quantity).toEqual(d(-100));
     expect(sut.rate).toEqual(undefined);
     expect(sut.type).toEqual('MARKET');
   });
 
   test('should construct a limit buy order', () => {
-    const sut = Order.limit(instrument, 100, 2000);
+    const sut = Order.limit(instrument, d(100), d(2000));
 
-    expect(sut.quantity).toEqual(100);
-    expect(sut.rate).toEqual(2000);
+    expect(sut.quantity).toEqual(d(100));
+    expect(sut.rate).toEqual(d(2000));
     expect(sut.type).toEqual('LIMIT');
   });
 
   test('should construct a limit sell order', () => {
-    const sut = Order.limit(instrument, -100, 2000);
+    const sut = Order.limit(instrument, d(-100), d(2000));
 
-    expect(sut.quantity).toEqual(-100);
-    expect(sut.rate).toEqual(2000);
+    expect(sut.quantity).toEqual(d(-100));
+    expect(sut.rate).toEqual(d(2000));
     expect(sut.type).toEqual('LIMIT');
   });
 });

package/src/domain/order.ts

@@ -1,6 +1,6 @@
 import { v4 } from 'uuid';
 
-import { timestamp } from '../shared';
+import { d, decimal, timestamp } from '../shared';
 import { Balance } from './balance';
 import { Component } from './component';
 import { invalidArgumentError } from './error';
@@ -22,31 +22,31 @@ export class Order implements Component {
   externalId: string;
   state: OrderState = 'NEW';
 
-  quantityExecuted = 0;
-  averageExecutionRate: number;
+  quantityExecuted = d.Zero;
+  averageExecutionRate: decimal;
   createdAt: timestamp;
 
-  static market(instrument: InstrumentSelector, quantity: number): Order {
+  static market(instrument: InstrumentSelector, quantity: decimal): Order {
     return new Order(instrument, 'MARKET', quantity);
   }
 
-  static limit(instrument: InstrumentSelector, quantity: number, rate: number): Order {
+  static limit(instrument: InstrumentSelector, quantity: decimal, rate: decimal): Order {
     return new Order(instrument, 'LIMIT', quantity, rate);
   }
 
   static stopMarket(
     instrument: InstrumentSelector,
-    quantity: number,
-    stopRate: number
+    quantity: decimal,
+    stopRate: decimal
   ): Order {
     return new Order(instrument, 'STOP-MARKET', quantity, undefined, stopRate);
   }
 
   static stopLimit(
     instrument: InstrumentSelector,
-    quantity: number,
-    rate: number,
-    stopRate: number
+    quantity: decimal,
+    rate: decimal,
+    stopRate: decimal
   ): Order {
     return new Order(instrument, 'STOP-LIMIT', quantity, rate, stopRate);
   }
@@ -54,15 +54,15 @@ export class Order implements Component {
   constructor(
     readonly instrument: InstrumentSelector,
     readonly type: OrderType,
-    readonly quantity: number,
-    readonly rate?: number,
-    readonly stopRate?: number
+    readonly quantity: decimal,
+    readonly rate?: decimal,
+    readonly stopRate?: decimal
   ) {
     if (!quantity || Number.isNaN(quantity)) {
       throw invalidArgumentError(quantity);
     }
 
-    if (rate && (Number.isNaN(rate) || rate <= 0)) {
+    if (rate && rate.lessThanOrEqualTo(0)) {
       throw invalidArgumentError(rate);
     }
   }
@@ -71,29 +71,32 @@ export class Order implements Component {
     return this.id;
   }
 
-  calculateBalanceToLock(base: Balance, quote: Balance): { base: number; quote: number } {
-    const qty = Math.abs(this.quantity);
+  calculateBalanceToLock(
+    base: Balance,
+    quote: Balance
+  ): { base: decimal; quote: decimal } {
+    const qty = this.quantity.abs();
 
-    if (this.quantity > 0) {
+    if (this.quantity.greaterThan(0)) {
       switch (this.type) {
         case 'MARKET':
           return {
-            base: 0,
+            base: d.Zero,
             quote: quote.free
           };
 
         case 'LIMIT':
           return {
-            base: 0,
-            quote: quote.asset.ceil(this.rate * qty)
+            base: d.Zero,
+            quote: quote.asset.ceil(this.rate.mul(qty))
           };
       }
     }
 
-    if (this.quantity < 0) {
+    if (this.quantity.lessThan(0)) {
       return {
         base: qty,
-        quote: 0
+        quote: d.Zero
       };
     }
   }

package/src/domain/orderbook.ts

@@ -1,7 +1,18 @@
 import { Instrument } from '../domain';
-import { timestamp } from '../shared';
+import { decimal, timestamp } from '../shared';
 import { Component } from './component';
 
+export interface Liquidity {
+  rate: decimal;
+  quantity: decimal;
+  next: this;
+}
+
+export const LiquidityAskComparer = (lhs: { rate: decimal }, rhs: { rate: decimal }) =>
+  lhs.rate.comparedTo(rhs.rate);
+export const LiquidityBidComparer = (lhs: { rate: decimal }, rhs: { rate: decimal }) =>
+  rhs.rate.comparedTo(lhs.rate);
+
 /**
  * Provides an access to pending buy and sell orders on the specific market.
  */
@@ -9,14 +20,9 @@ export class Orderbook implements Component {
   id: string;
   kind = 'orderbook';
   timestamp: timestamp;
-  bestAskRate: number;
-  bestAskQuantity: number;
-  bestBidRate: number;
-  bestBidQuantity: number;
 
-  get midRate(): number {
-    return this.instrument.quote.fixed((this.bestAskRate + this.bestBidRate) / 2);
-  }
+  asks: Liquidity;
+  bids: Liquidity;
 
   constructor(public readonly instrument: Instrument) {
     this.id = instrument.id;

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

@@ -1,5 +1,6 @@
-import { BehaviorSubject, map, Subject } from 'rxjs';
+import { BehaviorSubject, Subject } from 'rxjs';
 
+import { d } from '../shared';
 import { State } from '../store';
 import { Asset } from './asset';
 import { Balance } from './balance';
@@ -16,7 +17,7 @@ const instrument = new Instrument(
 
 describe('position', () => {
   test('should pipe a position', done => {
-    new BehaviorSubject<Component>(new Position('1', instrument, 'CROSS', 10, 2, 3))
+    new BehaviorSubject<Component>(new Position('1', instrument, 'CROSS', d(10), d(2), 3))
       .pipe(position(instrument))
       .subscribe({
         next: it => {
@@ -37,8 +38,8 @@ describe('position', () => {
 describe('positions', () => {
   const state = new State();
   const balance = new Balance(instrument.quote);
-  const position1 = new Position('1', instrument, 'CROSS', 10, 2, 3);
-  const position2 = new Position('2', instrument, 'CROSS', 20, 2, 3);
+  const position1 = new Position('1', instrument, 'CROSS', d(10), d(2), 3);
+  const position2 = new Position('2', instrument, 'CROSS', d(20), d(2), 3);
 
   beforeEach(() => {
     state.balance.upsert(balance);

package/src/domain/position.operator.ts

@@ -1,6 +1,6 @@
 import { filter, map, Observable, share, startWith } from 'rxjs';
 
-import { weightedMean } from '../shared';
+import { d, decimal, weightedMean } from '../shared';
 import { State } from '../store';
 import { InstrumentSelector } from './instrument';
 import { Position } from './position';
@@ -30,12 +30,15 @@ export function positions(selector: InstrumentSelector, state: State) {
 export function flatten() {
   return function (
     source: Observable<Position[]>
-  ): Observable<{ size: number; rate: number }> {
+  ): Observable<{ size: decimal; rate: decimal }> {
     return source.pipe(
       map(it => {
         if (it.length > 1) {
           return {
-            size: it.reduce((aggregate, position) => aggregate + position.size, 0),
+            size: it.reduce(
+              (aggregate, position) => aggregate.add(position.size),
+              d.Zero
+            ),
             rate: weightedMean(
               it.map(x => x.averageExecutionRate),
               it.map(x => x.size)
@@ -51,8 +54,8 @@ export function flatten() {
         }
 
         return {
-          size: 0,
-          rate: 0
+          size: d.Zero,
+          rate: d.Zero
         };
       }),
       share()

package/src/domain/position.spec.ts

@@ -1,3 +1,4 @@
+import { d } from '../shared';
 import { Asset } from './asset';
 import { Instrument } from './instrument';
 import { Position } from './position';
@@ -10,30 +11,30 @@ describe('Position', () => {
   );
 
   test('should construct a position', () => {
-    const sut = new Position('1', instrument, 'CROSS', 10, 2, 3);
+    const sut = new Position('1', instrument, 'CROSS', d(10), d(2), 3);
 
     expect(sut.id).toEqual('1');
     expect(sut.mode).toEqual('CROSS');
-    expect(sut.averageExecutionRate).toEqual(10);
-    expect(sut.size).toEqual(2);
+    expect(sut.averageExecutionRate).toEqual(d(10));
+    expect(sut.size).toEqual(d(2));
     expect(sut.leverage).toEqual(3);
     expect(sut.estimatedUnrealizedPnL).toEqual(undefined);
     expect(sut.id).toEqual('1');
   });
 
   test('should calculate correct margin', () => {
-    const sut = new Position('1', instrument, 'CROSS', 2511.81, 10.31, 20);
+    const sut = new Position('1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
 
-    expect(sut.margin).toEqual(0.5155);
+    expect(sut.margin).toEqual(d(0.5155));
     expect(sut.estimatedUnrealizedPnL).toEqual(undefined);
   });
 
   test('should calculate correct unrealized pnl', () => {
-    const sut = new Position('1', instrument, 'CROSS', 2511.81, 10.31, 20);
+    const sut = new Position('1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
 
-    const pnl = sut.calculateEstimatedUnrealizedPnL(2576.44);
+    const pnl = sut.calculateEstimatedUnrealizedPnL(d(2576.44));
 
-    expect(pnl).toEqual(0.2652);
-    expect(sut.estimatedUnrealizedPnL).toEqual(0.2652);
+    expect(pnl).toEqual(d(0.2652));
+    expect(sut.estimatedUnrealizedPnL).toEqual(d(0.2652));
   });
 });

package/src/domain/position.ts

@@ -1,5 +1,5 @@
 import { Instrument } from '../domain';
-import { pnl, timestamp } from '../shared';
+import { decimal, pnl, timestamp } from '../shared';
 import { Component } from './component';
 
 export type PositionMode = 'CROSS' | 'ISOLATED';
@@ -7,23 +7,23 @@ export type PositionMode = 'CROSS' | 'ISOLATED';
 export class Position implements Component {
   kind = 'position';
   timestamp: timestamp;
-  estimatedUnrealizedPnL?: number;
+  estimatedUnrealizedPnL?: decimal;
 
-  get margin(): number {
-    return this.instrument.quote.fixed(Math.abs(this.size) / this.leverage);
+  get margin(): decimal {
+    return this.instrument.quote.floor(this.size.abs().div(this.leverage));
   }
 
   constructor(
     readonly id: string,
     readonly instrument: Instrument,
     readonly mode: PositionMode,
-    public averageExecutionRate: number,
-    public size: number,
+    public averageExecutionRate: decimal,
+    public size: decimal,
     public leverage: number
   ) {}
 
-  calculateEstimatedUnrealizedPnL(rate: number): number {
-    this.estimatedUnrealizedPnL = this.instrument.quote.fixed(
+  calculateEstimatedUnrealizedPnL(rate: decimal): decimal {
+    this.estimatedUnrealizedPnL = this.instrument.quote.floor(
       pnl(this.averageExecutionRate, rate, this.size)
     );
 

package/src/domain/session.spec.ts

@@ -1,6 +1,6 @@
 import { Bootstrap } from '../bootstrap';
 import { Asset, Commission } from '../domain';
-import { now } from '../shared';
+import { d, now } from '../shared';
 import { InstrumentPatchEvent } from '../store';
 import { SessionDescriptor } from './session';
 
@@ -25,14 +25,14 @@ describe('Session', () => {
         now(),
         new Asset('de30', 'cex', 2),
         new Asset('usd', 'cex', 2),
-        new Commission(0, 0),
+        new Commission(d.Zero, d.Zero),
         ''
       ),
       new InstrumentPatchEvent(
         now(),
         new Asset('wig20', 'cex', 2),
         new Asset('pln', 'cex', 2),
-        new Commission(0, 0),
+        new Commission(d.Zero, d.Zero),
         ''
       )
     );

package/src/domain/session.ts

@@ -232,9 +232,7 @@ export class Session {
     return this.store.changes$.pipe(
       startWith(this.store.snapshot.universe.instrument.get(selector.id)),
       filter(it => it instanceof Instrument && it.id == selector.id),
-      switchMap(() =>
-        from(this.aggregate.history({ instrument: selector, timeframe, length }))
-      ),
+      switchMap(() => from(this.aggregate.history(selector, timeframe, length))),
       take(1),
       shareReplay(),
       mergeMap(it => it)

package/src/domain/trade.ts

@@ -1,4 +1,4 @@
-import { timestamp } from '../shared';
+import { decimal, timestamp } from '../shared';
 import { Instrument } from '.';
 import { Component } from './component';
 
@@ -10,8 +10,8 @@ export class Trade implements Component {
   id: string;
   kind = 'trade';
   timestamp: timestamp;
-  rate: number;
-  quantity: number;
+  rate: decimal;
+  quantity: decimal;
 
   constructor(public readonly instrument: Instrument) {
     this.id = instrument.id;

package/src/indicator/atr.ts

@@ -1,16 +1,17 @@
 import { map, Observable, share } from 'rxjs';
 
 import { Candle } from '../domain';
+import { decimal } from '../shared';
 import { rma } from './rma';
-import { truerange } from './truerange';
+import { trueRange } from './true-range';
 
 export function atr<T>(length: number, fn: (it: T) => Candle) {
-  return function (source: Observable<T>): Observable<[T, number]> {
+  return function (source: Observable<T>): Observable<[T, decimal]> {
     return source.pipe(
-      truerange(fn),
+      trueRange(fn),
       rma(length, ([, tr]) => tr),
-      map(([[it], truerange]) => {
-        const tuple: [T, number] = [it, truerange];
+      map(([[it], tr]) => {
+        const tuple: [T, decimal] = [it, tr];
 
         return tuple;
       }),