@quantform/core 0.5.15 → 0.6.4

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

package/src/domain/commission.ts

@@ -1,23 +1,27 @@
+import { d, decimal } from '../shared';
+
 export class Commission {
-  constructor(readonly makerRate: number, readonly takerRate: number) {}
+  static readonly Zero = commissionPercentOf({ maker: d.Zero, taker: d.Zero });
+
+  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,23 +1,25 @@
+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()}`
   );
 }
 
 export function invalidArgumentError(value: any) {
-  throw new Error(`invalid argument: ${value}`);
+  return new Error(`invalid argument: ${value}`);
 }
 
 export function invalidAssetSelectorError(selector: string) {
-  throw new Error(`invalid asset selector: ${selector}`);
+  return new Error(`invalid asset selector: ${selector}`);
 }
 
 export function invalidInstrumentSelectorError(selector: string) {
-  throw new Error(`invalid instrument selector: ${selector}`);
+  return new Error(`invalid instrument selector: ${selector}`);
 }
 
 export function adapterMismatchError() {

package/src/domain/index.ts

@@ -1,20 +1,21 @@
 export * from './asset';
 export * from './balance';
-export * from './balance.operator';
+export * from './balance-operator';
 export * from './error';
 export * from './candle';
-export * from './candle.operator';
+export * from './candle-operator';
 export * from './commission';
 export * from './component';
 export * from './instrument';
-export * from './instrument.operator';
+export * from './instrument-operator';
 export * from './order';
-export * from './order.operator';
+export * from './order-operator';
 export * from './orderbook';
-export * from './orderbook.operator';
+export * from './orderbook-operator';
 export * from './position';
-export * from './position.operator';
+export * from './position-operator';
 export * from './session';
+export * from './session-builder';
 export * from './timeframe';
 export * from './trade';
-export * from './trade.operator';
+export * from './trade-operator';

package/src/domain/{instrument.operator.spec.ts → instrument-operator.spec.ts}

@@ -2,16 +2,23 @@ import { Subject } from 'rxjs';
 
 import { State } from '../store';
 import { Asset } from './asset';
+import { Commission } from './commission';
 import { Component } from './component';
 import { Instrument, instrumentOf } from './instrument';
-import { instrument } from './instrument.operator';
+import { instrument } from './instrument-operator';
 
 describe('instrument', () => {
   const state = new State();
 
   beforeEach(() => {
     state.universe.instrument.upsert(
-      new Instrument(new Asset('abc', 'xyz', 4), new Asset('def', 'xyz', 4), 'abc-def')
+      new Instrument(
+        0,
+        new Asset('abc', 'xyz', 4),
+        new Asset('def', 'xyz', 4),
+        'abc-def',
+        Commission.Zero
+      )
     );
   });
 

package/src/domain/instrument.spec.ts

@@ -1,12 +1,19 @@
+import { d } from '../shared';
 import { Asset, assetOf } from './asset';
+import { commissionPercentOf } from './commission';
 import { Instrument, instrumentOf } from './instrument';
 
 describe('Instrument', () => {
   test('should construct a instrument', () => {
     const sut = new Instrument(
+      0,
       new Asset('abc', 'xyz', 4),
       new Asset('def', 'xyz', 4),
-      'abc-def'
+      'abc-def',
+      commissionPercentOf({
+        maker: d.Zero,
+        taker: d.Zero
+      })
     );
 
     expect(sut.base.name).toEqual('abc');

package/src/domain/instrument.ts

@@ -1,4 +1,3 @@
-import { timestamp } from '../shared';
 import { Asset, AssetSelector, AssetSelectorSeparator } from './asset';
 import { Commission } from './commission';
 import { Component } from './component';
@@ -27,13 +26,17 @@ export class InstrumentSelector {
  * Represents trading market which is made up by two trading assets (base and quoted).
  */
 export class Instrument extends InstrumentSelector implements Component {
-  kind = 'instrument';
-  timestamp: timestamp;
-  commission: Commission;
-  cross: Instrument;
-  leverage?: number = null;
-
-  constructor(readonly base: Asset, readonly quote: Asset, readonly raw: string) {
+  readonly kind = 'instrument';
+  readonly cross: Instrument | undefined;
+  leverage: number | undefined = undefined;
+
+  constructor(
+    public timestamp: number,
+    override readonly base: Asset,
+    override readonly quote: Asset,
+    readonly raw: string,
+    public commission: Commission
+  ) {
     super(base.name, quote.name, base.adapterName);
 
     if (base.adapterName != quote.adapterName) {

package/src/domain/{order.operator.spec.ts → order-operator.spec.ts}

@@ -1,26 +1,30 @@
 import { BehaviorSubject, map, Subject } from 'rxjs';
 
+import { d } from '../shared';
 import { InnerSet, State } from '../store';
 import { Asset } from './asset';
+import { Commission } from './commission';
 import { Component } from './component';
 import { Instrument } from './instrument';
 import { Order } from './order';
-import { order, orders } from './order.operator';
+import { order, orders } from './order-operator';
 
 const instrument = new Instrument(
+  0,
   new Asset('abc', 'xyz', 4),
   new Asset('def', 'xyz', 4),
-  'abc-def'
+  'abc-def',
+  Commission.Zero
 );
 
 describe('order', () => {
   test('should pipe an order', done => {
-    new BehaviorSubject<Component>(Order.market(instrument, -100))
+    new BehaviorSubject<Component>(new Order(0, '1', instrument, d(-100), 0))
       .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 +45,9 @@ describe('positions', () => {
   beforeEach(() => {
     state = new State();
 
-    order1 = Order.market(instrument, -100);
-    order2 = Order.limit(instrument, 100, 10);
-    order3 = Order.market(instrument, 100);
+    order1 = new Order(0, '1', instrument, d(-100), 0);
+    order2 = new Order(0, '2', instrument, d(100), 0, d(10));
+    order3 = new Order(0, '3', instrument, d(100), 0);
 
     state.order.upsert(new InnerSet<Order>(instrument.id, [order1, order2, order3]));
   });

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

@@ -17,7 +17,7 @@ export function orders(selector: InstrumentSelector, state: State) {
   return (source$: Observable<Component>) =>
     source$.pipe(
       filter(it => it instanceof Order && it.instrument.id == selector.id),
-      map(() => state.order.get(selector.id).asReadonlyArray()),
-      startWith(state.order.get(selector.id).asReadonlyArray())
+      map(() => state.order.get(selector.id)?.asReadonlyArray() ?? []),
+      startWith(state.order.get(selector.id)?.asReadonlyArray() ?? [])
     );
 }

package/src/domain/order.spec.ts

@@ -1,43 +1,43 @@
+import { d } from '../shared';
 import { Asset } from './asset';
+import { Commission } from './commission';
 import { Instrument } from './instrument';
 import { Order } from './order';
 
 describe('Order', () => {
   const instrument = new Instrument(
+    0,
     new Asset('abc', 'xyz', 4),
     new Asset('def', 'xyz', 4),
-    'abc-def'
+    'abc-def',
+    Commission.Zero
   );
 
   test('should construct a market buy order', () => {
-    const sut = Order.market(instrument, 100);
+    const sut = new Order(0, '1', instrument, d(100), 0);
 
-    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 = new Order(0, '1', instrument, d(-100), 0);
 
-    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 = new Order(0, '1', instrument, d(100), 0, d(2000));
 
-    expect(sut.quantity).toEqual(100);
-    expect(sut.rate).toEqual(2000);
-    expect(sut.type).toEqual('LIMIT');
+    expect(sut.quantity).toEqual(d(100));
+    expect(sut.rate).toEqual(d(2000));
   });
 
   test('should construct a limit sell order', () => {
-    const sut = Order.limit(instrument, -100, 2000);
+    const sut = new Order(0, '1', instrument, d(-100), 0, d(2000));
 
-    expect(sut.quantity).toEqual(-100);
-    expect(sut.rate).toEqual(2000);
-    expect(sut.type).toEqual('LIMIT');
+    expect(sut.quantity).toEqual(d(-100));
+    expect(sut.rate).toEqual(d(2000));
   });
 });

package/src/domain/order.ts

@@ -1,12 +1,9 @@
-import { v4 } from 'uuid';
-
-import { timestamp } from '../shared';
+import { d, decimal } from '../shared';
 import { Balance } from './balance';
 import { Component } from './component';
 import { invalidArgumentError } from './error';
-import { InstrumentSelector } from './instrument';
+import { Instrument } from './instrument';
 
-export type OrderType = 'MARKET' | 'LIMIT' | 'STOP-MARKET' | 'STOP-LIMIT';
 export type OrderState =
   | 'NEW'
   | 'PENDING'
@@ -16,53 +13,26 @@ export type OrderState =
   | 'REJECTED';
 
 export class Order implements Component {
-  kind = 'order';
-  timestamp: timestamp;
-  id = v4();
-  externalId: string;
+  readonly kind = 'order';
   state: OrderState = 'NEW';
-
-  quantityExecuted = 0;
-  averageExecutionRate: number;
-  createdAt: timestamp;
-
-  static market(instrument: InstrumentSelector, quantity: number): Order {
-    return new Order(instrument, 'MARKET', quantity);
-  }
-
-  static limit(instrument: InstrumentSelector, quantity: number, rate: number): Order {
-    return new Order(instrument, 'LIMIT', quantity, rate);
-  }
-
-  static stopMarket(
-    instrument: InstrumentSelector,
-    quantity: number,
-    stopRate: number
-  ): Order {
-    return new Order(instrument, 'STOP-MARKET', quantity, undefined, stopRate);
-  }
-
-  static stopLimit(
-    instrument: InstrumentSelector,
-    quantity: number,
-    rate: number,
-    stopRate: number
-  ): Order {
-    return new Order(instrument, 'STOP-LIMIT', quantity, rate, stopRate);
-  }
+  quantityExecuted = d.Zero;
+  averageExecutionRate?: decimal;
+  externalId?: string;
 
   constructor(
-    readonly instrument: InstrumentSelector,
-    readonly type: OrderType,
-    readonly quantity: number,
-    readonly rate?: number,
-    readonly stopRate?: number
+    public timestamp: number,
+    readonly id: string,
+    readonly instrument: Instrument,
+    readonly quantity: decimal,
+    public createdAt: number,
+    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,30 +41,33 @@ export class Order implements Component {
     return this.id;
   }
 
-  calculateBalanceToLock(base: Balance, quote: Balance): { base: number; quote: number } {
-    const qty = Math.abs(this.quantity);
-
-    if (this.quantity > 0) {
-      switch (this.type) {
-        case 'MARKET':
-          return {
-            base: 0,
-            quote: quote.free
-          };
+  calculateBalanceToLock(
+    base: Balance,
+    quote: Balance
+  ): { base?: decimal; quote?: decimal } {
+    const qty = this.quantity.abs();
 
-        case 'LIMIT':
-          return {
-            base: 0,
-            quote: quote.asset.ceil(this.rate * qty)
-          };
+    if (this.quantity.greaterThan(0)) {
+      if (this.rate) {
+        return {
+          base: d.Zero,
+          quote: quote.asset.ceil(this.rate.mul(qty))
+        };
+      } else {
+        return {
+          base: d.Zero,
+          quote: quote.free
+        };
       }
     }
 
-    if (this.quantity < 0) {
+    if (this.quantity.lessThan(0)) {
       return {
         base: qty,
-        quote: 0
+        quote: d.Zero
       };
     }
+
+    return {};
   }
 }

package/src/domain/{orderbook.operator.spec.ts → orderbook-operator.spec.ts}

@@ -1,22 +1,34 @@
 import { Subject } from 'rxjs';
 
+import { d } from '../shared';
 import { State } from '../store';
 import { Asset } from './asset';
+import { Commission } from './commission';
 import { Component } from './component';
 import { Instrument } from './instrument';
 import { Orderbook } from './orderbook';
-import { orderbook } from './orderbook.operator';
+import { orderbook } from './orderbook-operator';
 
 describe('orderbook', () => {
   const instrument = new Instrument(
+    0,
     new Asset('abc', 'xyz', 4),
     new Asset('def', 'xyz', 4),
-    'abc-def'
+    'abc-def',
+    Commission.Zero
   );
 
   test('should pipe an orderbook on subscription', done => {
     const state = new State();
-    state.orderbook.upsert(new Orderbook(instrument));
+
+    state.orderbook.upsert(
+      new Orderbook(
+        0,
+        instrument,
+        { rate: d(2), quantity: d(1), next: undefined },
+        { rate: d(1), quantity: d(1), next: undefined }
+      )
+    );
 
     new Subject<Component>().pipe(orderbook(instrument, state)).subscribe({
       next: it => {

package/src/domain/orderbook.spec.ts

@@ -1,16 +1,25 @@
+import { d } from '../shared';
 import { Asset } from './asset';
+import { Commission } from './commission';
 import { Instrument } from './instrument';
 import { Orderbook } from './orderbook';
 
 describe('Orderbook', () => {
   const instrument = new Instrument(
+    0,
     new Asset('abc', 'xyz', 4),
     new Asset('def', 'xyz', 4),
-    'abc-def'
+    'abc-def',
+    Commission.Zero
   );
 
   test('should construct an empty orderbook', () => {
-    const sut = new Orderbook(instrument);
+    const sut = new Orderbook(
+      0,
+      instrument,
+      { rate: d(2), quantity: d(1), next: undefined },
+      { rate: d(1), quantity: d(1), next: undefined }
+    );
 
     expect(sut.id).toEqual(instrument.id);
   });

package/src/domain/orderbook.ts

@@ -1,24 +1,31 @@
 import { Instrument } from '../domain';
-import { timestamp } from '../shared';
+import { decimal } from '../shared';
 import { Component } from './component';
 
+export interface Liquidity {
+  rate: decimal;
+  quantity: decimal;
+  next: this | undefined;
+}
+
+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.
  */
 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);
-  }
+  readonly id: string;
+  readonly kind = 'orderbook';
 
-  constructor(public readonly instrument: Instrument) {
+  constructor(
+    public timestamp: number,
+    public readonly instrument: Instrument,
+    public asks: Liquidity,
+    public bids: Liquidity
+  ) {
     this.id = instrument.id;
   }
 

package/src/domain/{position.operator.spec.ts → position-operator.spec.ts}

@@ -1,22 +1,28 @@
-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';
+import { Commission } from './commission';
 import { Component } from './component';
 import { Instrument } from './instrument';
 import { Position } from './position';
-import { position, positions } from './position.operator';
+import { position, positions } from './position-operator';
 
 const instrument = new Instrument(
+  0,
   new Asset('abc', 'xyz', 4),
   new Asset('def', 'xyz', 4),
-  'abc-def'
+  'abc-def',
+  Commission.Zero
 );
 
 describe('position', () => {
   test('should pipe a position', done => {
-    new BehaviorSubject<Component>(new Position('1', instrument, 'CROSS', 10, 2, 3))
+    new BehaviorSubject<Component>(
+      new Position(0, '1', instrument, 'CROSS', d(10), d(2), 3)
+    )
       .pipe(position(instrument))
       .subscribe({
         next: it => {
@@ -36,9 +42,9 @@ 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 balance = new Balance(0, instrument.quote);
+  const position1 = new Position(0, '1', instrument, 'CROSS', d(10), d(2), 3);
+  const position2 = new Position(0, '2', instrument, 'CROSS', d(20), d(2), 3);
 
   beforeEach(() => {
     state.balance.upsert(balance);