@quantform/core 0.5.13 → 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(maker: number, taker: number) {
-  return new Commission(maker / 100.0, 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/component.ts

@@ -1,6 +1,7 @@
 import { timestamp } from '../shared';
 
 export interface Component {
+  id: string;
   kind: string;
   timestamp: timestamp;
 }

package/src/domain/error.ts

@@ -0,0 +1,27 @@
+import { decimal } from '../shared';
+
+export function insufficientFundsError(
+  assetName: string,
+  requiredAmount: decimal,
+  availableAmount: decimal
+) {
+  return new Error(
+    `insufficient funds of ${assetName} has: ${availableAmount.toString()} requires: ${requiredAmount.toString()}`
+  );
+}
+
+export function invalidArgumentError(value: any) {
+  throw new Error(`invalid argument: ${value}`);
+}
+
+export function invalidAssetSelectorError(selector: string) {
+  throw new Error(`invalid asset selector: ${selector}`);
+}
+
+export function invalidInstrumentSelectorError(selector: string) {
+  throw new Error(`invalid instrument selector: ${selector}`);
+}
+
+export function adapterMismatchError() {
+  return new Error('adapters must be the same');
+}

package/src/domain/index.ts

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

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

@@ -0,0 +1,28 @@
+import { Subject } from 'rxjs';
+
+import { State } from '../store';
+import { Asset } from './asset';
+import { Component } from './component';
+import { Instrument, instrumentOf } from './instrument';
+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')
+    );
+  });
+
+  test('should pipe an instrument on subscription', done => {
+    new Subject<Component>()
+      .pipe(instrument(instrumentOf('xyz:abc-def'), state))
+      .subscribe({
+        next: it => {
+          expect(it.id).toEqual('xyz:abc-def');
+          done();
+        }
+      });
+  });
+});

package/src/domain/instrument.operator.ts

@@ -0,0 +1,25 @@
+import { distinctUntilChanged, filter, map, Observable, startWith } from 'rxjs';
+
+import { State } from '../store';
+import { Component } from './component';
+import { Instrument, InstrumentSelector } from './instrument';
+
+export function instrument(selector: InstrumentSelector, state: State) {
+  return (source$: Observable<Component>) =>
+    source$.pipe(
+      startWith(state.universe.instrument.get(selector.id)),
+      filter(it => it instanceof Instrument && it.id == selector.id),
+      map(it => it as Instrument)
+    );
+}
+
+export function instruments(state: State) {
+  return (source$: Observable<Component>) =>
+    source$.pipe(
+      filter(it => it instanceof Instrument),
+      map(() => state.universe.instrument.asReadonlyArray()),
+      startWith(state.universe.instrument.asReadonlyArray()),
+      filter(it => it.length > 0),
+      distinctUntilChanged((lhs, rhs) => lhs.length == rhs.length)
+    );
+}

package/src/domain/instrument.spec.ts

@@ -1,8 +1,8 @@
 import { Asset, assetOf } from './asset';
 import { Instrument, instrumentOf } from './instrument';
 
-describe('instrument tests', () => {
-  test('should instantiate proper instrument', () => {
+describe('Instrument', () => {
+  test('should construct a instrument', () => {
     const sut = new Instrument(
       new Asset('abc', 'xyz', 4),
       new Asset('def', 'xyz', 4),
@@ -10,63 +10,55 @@ describe('instrument tests', () => {
     );
 
     expect(sut.base.name).toEqual('abc');
-    expect(sut.base.adapter).toEqual('xyz');
+    expect(sut.base.adapterName).toEqual('xyz');
     expect(sut.quote.name).toEqual('def');
-    expect(sut.quote.adapter).toEqual('xyz');
-    expect(sut.toString()).toEqual('xyz:abc-def');
+    expect(sut.quote.adapterName).toEqual('xyz');
+    expect(sut.id).toEqual('xyz:abc-def');
   });
 });
 
-describe('instrument selector tests', () => {
-  test('should instantiate proper instrument selector', () => {
+describe('InstrumentSelector', () => {
+  test('should construct a instrument selector', () => {
     const sut = instrumentOf('xyz:abc-def');
 
     expect(sut.base.name).toEqual('abc');
-    expect(sut.base.adapter).toEqual('xyz');
+    expect(sut.base.adapterName).toEqual('xyz');
     expect(sut.quote.name).toEqual('def');
-    expect(sut.quote.adapter).toEqual('xyz');
-    expect(sut.toString()).toEqual('xyz:abc-def');
+    expect(sut.quote.adapterName).toEqual('xyz');
+    expect(sut.id).toEqual('xyz:abc-def');
   });
 
-  test('should instantiate proper instrument selector capital case', () => {
+  test('should construct a instrument selector capital case', () => {
     const sut = instrumentOf('XYZ:ABC-DEF');
 
     expect(sut.base.name).toEqual('abc');
-    expect(sut.base.adapter).toEqual('xyz');
+    expect(sut.base.adapterName).toEqual('xyz');
     expect(sut.quote.name).toEqual('def');
-    expect(sut.quote.adapter).toEqual('xyz');
-    expect(sut.toString()).toEqual('xyz:abc-def');
+    expect(sut.quote.adapterName).toEqual('xyz');
+    expect(sut.id).toEqual('xyz:abc-def');
   });
 
   test('should throw invalid format message for missing separator', () => {
-    const fn = () => {
-      instrumentOf('xyzabc-def');
-    };
+    const fn = () => instrumentOf('xyzabc-def');
 
-    expect(fn).toThrow(Error);
+    expect(fn).toThrowError();
   });
 
   test('should throw invalid format message for multiple separators', () => {
-    const fn = () => {
-      instrumentOf('xyz:abc:-def');
-    };
+    const fn = () => instrumentOf('xyz:abc:-def');
 
-    expect(fn).toThrow(Error);
+    expect(fn).toThrowError();
   });
 
   test('should throw invalid format message for missing pair name', () => {
-    const fn = () => {
-      instrumentOf('xyz:');
-    };
+    const fn = () => instrumentOf('xyz:');
 
-    expect(fn).toThrow(Error);
+    expect(fn).toThrowError();
   });
 
   test('should throw invalid format message for missing adapter name', () => {
-    const fn = () => {
-      assetOf(':abc-def');
-    };
+    const fn = () => assetOf(':abc-def');
 
-    expect(fn).toThrow(Error);
+    expect(fn).toThrowError();
   });
 });

package/src/domain/instrument.ts

@@ -1,11 +1,13 @@
 import { timestamp } from '../shared';
-import { Asset, AssetSelector } from './asset';
+import { Asset, AssetSelector, AssetSelectorSeparator } from './asset';
 import { Commission } from './commission';
 import { Component } from './component';
+import { adapterMismatchError, invalidInstrumentSelectorError } from './error';
 
-export class InstrumentSelector {
-  private readonly id: string;
+export const InstrumentSelectorSeparator = '-';
 
+export class InstrumentSelector {
+  readonly id: string;
   readonly base: AssetSelector;
   readonly quote: AssetSelector;
 
@@ -13,7 +15,7 @@ export class InstrumentSelector {
     this.base = new AssetSelector(base.toLowerCase(), adapter.toLowerCase());
     this.quote = new AssetSelector(quote.toLowerCase(), adapter.toLowerCase());
 
-    this.id = `${this.base.toString()}-${this.quote.name}`;
+    this.id = `${this.base.id}${InstrumentSelectorSeparator}${this.quote.name}`;
   }
 
   toString(): string {
@@ -32,17 +34,24 @@ export class Instrument extends InstrumentSelector implements Component {
   leverage?: number = null;
 
   constructor(readonly base: Asset, readonly quote: Asset, readonly raw: string) {
-    super(base.name, quote.name, base.adapter);
+    super(base.name, quote.name, base.adapterName);
 
-    if (base.adapter != quote.adapter) {
-      throw new Error('Adapter mismatch!');
+    if (base.adapterName != quote.adapterName) {
+      throw adapterMismatchError();
     }
   }
 }
 
-export function instrumentOf(instrument: string): InstrumentSelector {
-  const section = instrument.split(':');
-  const asset = section[1].split('-');
+export function instrumentOf(selector: string): InstrumentSelector {
+  const [adapterName, asset, ...rest] = selector.split(AssetSelectorSeparator);
+  if (!adapterName || !asset || rest.length) {
+    throw invalidInstrumentSelectorError(selector);
+  }
+
+  const [baseAssetName, quoteAssetName] = asset.split(InstrumentSelectorSeparator);
+  if (!baseAssetName || !quoteAssetName) {
+    throw invalidInstrumentSelectorError(selector);
+  }
 
-  return new InstrumentSelector(asset[0], asset[1], section[0]);
+  return new InstrumentSelector(baseAssetName, quoteAssetName, adapterName);
 }

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

@@ -0,0 +1,82 @@
+import { BehaviorSubject, map, Subject } from 'rxjs';
+
+import { d } from '../shared';
+import { InnerSet, State } from '../store';
+import { Asset } from './asset';
+import { Component } from './component';
+import { Instrument } from './instrument';
+import { Order } from './order';
+import { order, orders } from './order.operator';
+
+const instrument = new Instrument(
+  new Asset('abc', 'xyz', 4),
+  new Asset('def', 'xyz', 4),
+  'abc-def'
+);
+
+describe('order', () => {
+  test('should pipe an order', done => {
+    new BehaviorSubject<Component>(Order.market(instrument, d(-100)))
+      .pipe(order(instrument))
+      .subscribe({
+        next: it => {
+          expect(it.instrument).toEqual(instrument);
+          expect(it.quantity).toEqual(d(-100));
+          done();
+        }
+      });
+  });
+
+  test('should skip a pipe', done => {
+    new BehaviorSubject<Component>(instrument).pipe(order(instrument)).subscribe({
+      next: () => fail(),
+      complete: done()
+    });
+  });
+});
+
+describe('positions', () => {
+  let state: State;
+  let order1: Order, order2: Order, order3: Order;
+
+  beforeEach(() => {
+    state = new State();
+
+    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]));
+  });
+
+  test('should pipe all orders on subscription start', done => {
+    order1.state = 'NEW';
+    order2.state = 'NEW';
+    order3.state = 'NEW';
+
+    new Subject<Component>().pipe(orders(instrument, state)).subscribe({
+      next: it => {
+        expect(it.length).toEqual(3);
+        done();
+      }
+    });
+  });
+
+  test('should pipe pending orders on subscription start', done => {
+    order1.state = 'NEW';
+    order2.state = 'PENDING';
+    order3.state = 'PENDING';
+
+    new Subject<Component>()
+      .pipe(
+        orders(instrument, state),
+        map(it => it.filter(order => order.state === 'PENDING'))
+      )
+      .subscribe({
+        next: it => {
+          expect(it.length).toEqual(2);
+          done();
+        }
+      });
+  });
+});

package/src/domain/order.operator.ts

@@ -0,0 +1,23 @@
+import { filter, map, Observable, startWith } from 'rxjs';
+
+import { State } from '../store';
+import { Component } from './component';
+import { InstrumentSelector } from './instrument';
+import { Order } from './order';
+
+export function order(selector: InstrumentSelector) {
+  return (source$: Observable<Component>) =>
+    source$.pipe(
+      filter(it => it instanceof Order && it.instrument.id == selector.id),
+      map(it => it as Order)
+    );
+}
+
+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())
+    );
+}

package/src/domain/order.spec.ts

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

package/src/domain/order.ts

@@ -1,10 +1,11 @@
 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';
 import { InstrumentSelector } from './instrument';
 
-export type OrderSide = 'SELL' | 'BUY';
 export type OrderType = 'MARKET' | 'LIMIT' | 'STOP-MARKET' | 'STOP-LIMIT';
 export type OrderState =
   | 'NEW'
@@ -21,83 +22,82 @@ export class Order implements Component {
   externalId: string;
   state: OrderState = 'NEW';
 
-  quantityExecuted = 0;
-  averageExecutionRate: number;
+  quantityExecuted = d.Zero;
+  averageExecutionRate: decimal;
   createdAt: timestamp;
-  comment: string;
 
-  static sellMarket(instrument: InstrumentSelector, quantity: number): Order {
-    return new Order(instrument, 'SELL', 'MARKET', quantity);
+  static market(instrument: InstrumentSelector, quantity: decimal): Order {
+    return new Order(instrument, 'MARKET', quantity);
   }
 
-  static buyMarket(instrument: InstrumentSelector, quantity: number): Order {
-    return new Order(instrument, 'BUY', 'MARKET', quantity);
+  static limit(instrument: InstrumentSelector, quantity: decimal, rate: decimal): Order {
+    return new Order(instrument, 'LIMIT', quantity, rate);
   }
 
-  static sellLimit(
+  static stopMarket(
     instrument: InstrumentSelector,
-    quantity: number,
-    rate: number
+    quantity: decimal,
+    stopRate: decimal
   ): Order {
-    return new Order(instrument, 'SELL', 'LIMIT', quantity, rate);
+    return new Order(instrument, 'STOP-MARKET', quantity, undefined, stopRate);
   }
 
-  static buyLimit(instrument: InstrumentSelector, quantity: number, rate: number): Order {
-    return new Order(instrument, 'BUY', 'LIMIT', quantity, rate);
-  }
-
-  static sellStopMarket(
-    instrument: InstrumentSelector,
-    quantity: number,
-    stopRate: number
-  ): Order {
-    return new Order(instrument, 'SELL', 'STOP-MARKET', quantity, null, stopRate);
-  }
-
-  static buyStopMarket(
+  static stopLimit(
     instrument: InstrumentSelector,
-    quantity: number,
-    stopRate: number
+    quantity: decimal,
+    rate: decimal,
+    stopRate: decimal
   ): Order {
-    return new Order(instrument, 'BUY', 'STOP-MARKET', quantity, null, stopRate);
-  }
-
-  static sellStopLimit(
-    instrument: InstrumentSelector,
-    quantity: number,
-    rate: number,
-    stopRate: number
-  ): Order {
-    return new Order(instrument, 'SELL', 'STOP-LIMIT', quantity, rate, stopRate);
-  }
-
-  static buyStopLimit(
-    instrument: InstrumentSelector,
-    quantity: number,
-    rate: number,
-    stopRate: number
-  ): Order {
-    return new Order(instrument, 'BUY', 'STOP-LIMIT', quantity, rate, stopRate);
+    return new Order(instrument, 'STOP-LIMIT', quantity, rate, stopRate);
   }
 
   constructor(
     readonly instrument: InstrumentSelector,
-    readonly side: OrderSide,
     readonly type: OrderType,
-    readonly quantity: number,
-    readonly rate: number = null,
-    readonly stopRate: number = null
+    readonly quantity: decimal,
+    readonly rate?: decimal,
+    readonly stopRate?: decimal
   ) {
-    if (quantity <= 0 || Number.isNaN(quantity)) {
-      throw new Error(`invalid order quantity: ${quantity}`);
+    if (!quantity || Number.isNaN(quantity)) {
+      throw invalidArgumentError(quantity);
     }
 
-    if (rate && (Number.isNaN(quantity) || rate <= 0)) {
-      throw new Error('invalid order rate');
+    if (rate && rate.lessThanOrEqualTo(0)) {
+      throw invalidArgumentError(rate);
     }
   }
 
   toString() {
     return this.id;
   }
+
+  calculateBalanceToLock(
+    base: Balance,
+    quote: Balance
+  ): { base: decimal; quote: decimal } {
+    const qty = this.quantity.abs();
+
+    if (this.quantity.greaterThan(0)) {
+      switch (this.type) {
+        case 'MARKET':
+          return {
+            base: d.Zero,
+            quote: quote.free
+          };
+
+        case 'LIMIT':
+          return {
+            base: d.Zero,
+            quote: quote.asset.ceil(this.rate.mul(qty))
+          };
+      }
+    }
+
+    if (this.quantity.lessThan(0)) {
+      return {
+        base: qty,
+        quote: d.Zero
+      };
+    }
+  }
 }

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

@@ -0,0 +1,28 @@
+import { Subject } from 'rxjs';
+
+import { State } from '../store';
+import { Asset } from './asset';
+import { Component } from './component';
+import { Instrument } from './instrument';
+import { Orderbook } from './orderbook';
+import { orderbook } from './orderbook.operator';
+
+describe('orderbook', () => {
+  const instrument = new Instrument(
+    new Asset('abc', 'xyz', 4),
+    new Asset('def', 'xyz', 4),
+    'abc-def'
+  );
+
+  test('should pipe an orderbook on subscription', done => {
+    const state = new State();
+    state.orderbook.upsert(new Orderbook(instrument));
+
+    new Subject<Component>().pipe(orderbook(instrument, state)).subscribe({
+      next: it => {
+        expect(it.id).toEqual(instrument.id);
+        done();
+      }
+    });
+  });
+});

package/src/domain/orderbook.operator.ts

@@ -0,0 +1,15 @@
+import { filter, map, Observable, startWith } from 'rxjs';
+
+import { State } from '../store';
+import { Component } from './component';
+import { InstrumentSelector } from './instrument';
+import { Orderbook } from './orderbook';
+
+export function orderbook(selector: InstrumentSelector, state: State) {
+  return (source$: Observable<Component>) =>
+    source$.pipe(
+      startWith(state.orderbook.get(selector.id)),
+      filter(it => it instanceof Orderbook && it.instrument.id == selector.id),
+      map(it => it as Orderbook)
+    );
+}

package/src/domain/orderbook.spec.ts

@@ -0,0 +1,17 @@
+import { Asset } from './asset';
+import { Instrument } from './instrument';
+import { Orderbook } from './orderbook';
+
+describe('Orderbook', () => {
+  const instrument = new Instrument(
+    new Asset('abc', 'xyz', 4),
+    new Asset('def', 'xyz', 4),
+    'abc-def'
+  );
+
+  test('should construct an empty orderbook', () => {
+    const sut = new Orderbook(instrument);
+
+    expect(sut.id).toEqual(instrument.id);
+  });
+});