@quantform/core 0.5.23 → 0.6.5

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';
@@ -17,23 +16,22 @@ export class InstrumentSelector {
 
     this.id = `${this.base.id}${InstrumentSelectorSeparator}${this.quote.name}`;
   }
-
-  toString(): string {
-    return this.id;
-  }
 }
 
 /**
  * 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 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/ohlc-operator.spec.ts

@@ -0,0 +1,126 @@
+import { from } from 'rxjs';
+
+import { d } from '../shared';
+import { Ohlc } from './ohlc';
+import { mergeOhlc, ohlc, ohlcCompleted } from './ohlc-operator';
+
+describe('ohlc', () => {
+  test('should aggregate and pipe ohlc 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 Ohlc(0, d(1), d(1), d(1), d(1)),
+      new Ohlc(0, d(1), d(2), d(1), d(2)),
+      new Ohlc(0, d(1), d(3), d(1), d(3)),
+      new Ohlc(0, d(1), d(3), d.Zero, d.Zero),
+      new Ohlc(5, d.Zero, d(7), d(7), d(7)),
+      new Ohlc(5, d.Zero, d(8), d(7), d(8))
+    ].reverse();
+
+    input$.pipe(ohlc(5, it => it.rate)).subscribe({
+      next: it => {
+        expect(it).toEqual(output.pop());
+        if (output.length === 0) {
+          done();
+        }
+      }
+    });
+  });
+});
+
+describe('ohlcCompleted', () => {
+  test('should aggregate and pipe distinct completed ohlc', 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(
+        ohlc(5, it => it.rate),
+        ohlcCompleted()
+      )
+      .subscribe({
+        next: it => {
+          expect(it).toEqual(new Ohlc(0, d(1), d(3), d.Zero, d.Zero));
+          done();
+        }
+      });
+  });
+});
+
+describe('mergeOhlc', () => {
+  test('should pipe and merge ohlc from history', done => {
+    const history$ = from([
+      new Ohlc(1, d(1), d(1.5), d(0.5), d(2)),
+      new Ohlc(2, d(2), d(2.5), d(1.5), d(3)),
+      new Ohlc(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 Ohlc(1, d(1), d(1.5), d(0.5), d(2)),
+      new Ohlc(2, d(2), d(2.5), d(1.5), d(3)),
+      new Ohlc(3, d(3), d(5), d(2.5), d(5)),
+      new Ohlc(4, d(5), d(3), d(3), d(3)),
+      new Ohlc(5, d(3), d(4), d(4), d(4))
+    ].reverse();
+
+    input$.pipe(mergeOhlc(1, it => it.rate, history$)).subscribe({
+      next: it => {
+        expect(it).toEqual(output.pop());
+        if (output.length === 0) {
+          done();
+        }
+      }
+    });
+  });
+
+  test('should pipe and not merge ohlc from history', done => {
+    const history$ = from([
+      new Ohlc(1, d(1), d(1.5), d(0.5), d(2)),
+      new Ohlc(2, d(2), d(2.5), d(1.5), d(3)),
+      new Ohlc(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 Ohlc(1, d(1), d(1.5), d(0.5), d(2)),
+      new Ohlc(2, d(2), d(2.5), d(1.5), d(3)),
+      new Ohlc(3, d(3), d(3.5), d(2.5), d(4)),
+      new Ohlc(4, d(4), d(5), d(5), d(5)),
+      new Ohlc(5, d(5), d(3), d(3), d(3)),
+      new Ohlc(6, d(3), d(4), d(4), d(4))
+    ].reverse();
+
+    input$.pipe(mergeOhlc(1, it => it.rate, history$)).subscribe({
+      next: it => {
+        expect(it).toEqual(output.pop());
+        if (output.length === 0) {
+          done();
+        }
+      }
+    });
+  });
+});

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

@@ -5,35 +5,42 @@ import {
   map,
   mergeMap,
   Observable,
+  OperatorFunction,
   share,
   skipLast,
   switchMap
 } from 'rxjs';
 
 import { decimal } from '../shared';
-import { Candle } from './candle';
+import { Ohlc } from './ohlc';
 import { tf } from './timeframe';
 
-function aggregate(candle: Candle, timeframe: number, value: decimal, timestamp: number) {
+function aggregate(
+  candle: Ohlc | undefined,
+  timeframe: number,
+  value: decimal,
+  timestamp: number
+) {
   const frame = tf(timestamp, timeframe);
 
   if (!candle) {
-    return new Candle(frame, value, value, value, value);
+    return new Ohlc(frame, value, value, value, value);
   }
 
   if (candle.timestamp === frame) {
     candle.apply(value);
+    return undefined;
   } else {
-    return new Candle(frame, candle.close, value, value, value);
+    return new Ohlc(frame, candle.close, value, value, value);
   }
 }
 
-export function candle<T extends { timestamp: number }>(
+export function ohlc<T extends { timestamp: number }>(
   timeframe: number,
   fn: (x: T) => decimal,
-  candleToStartWith: Candle = undefined
+  candleToStartWith?: Ohlc
 ) {
-  return function (source: Observable<T>): Observable<Candle> {
+  return function (source: Observable<T>): Observable<Ohlc> {
     let candle = candleToStartWith;
 
     return source.pipe(
@@ -45,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];
           }
         }
 
@@ -53,7 +65,11 @@ export function candle<T extends { timestamp: number }>(
           candleToStartWith = undefined;
         }
 
-        return [candle];
+        if (candle) {
+          return [candle];
+        }
+
+        return [];
       }),
       mergeMap(it => it),
       share()
@@ -61,18 +77,18 @@ export function candle<T extends { timestamp: number }>(
   };
 }
 
-export function mergeCandle<T extends { timestamp: number }>(
+export function mergeOhlc<T extends { timestamp: number }>(
   timeframe: number,
   fn: (x: T) => decimal,
-  history$: Observable<Candle>
+  history$: Observable<Ohlc>
 ) {
-  return function (source$: Observable<T>): Observable<Candle> {
+  return function (source$: Observable<T>): Observable<Ohlc> {
     return concat(
       history$.pipe(skipLast(1)),
       history$.pipe(
         last(),
         switchMap(lastHistoricalCandle =>
-          source$.pipe(candle(timeframe, fn, lastHistoricalCandle))
+          source$.pipe(ohlc(timeframe, fn, lastHistoricalCandle))
         ),
         share()
       )
@@ -80,10 +96,10 @@ export function mergeCandle<T extends { timestamp: number }>(
   };
 }
 
-export function candleCompleted(): (source: Observable<Candle>) => Observable<Candle> {
-  let currCandle: Candle;
+export function ohlcCompleted(): (source: Observable<Ohlc>) => Observable<Ohlc> {
+  let currCandle: Ohlc;
 
-  return (source: Observable<Candle>) =>
+  return (source: Observable<Ohlc>) =>
     source.pipe(
       map(it => {
         if (!currCandle) {
@@ -101,7 +117,7 @@ export function candleCompleted(): (source: Observable<Candle>) => Observable<Ca
           return undefined;
         }
       }),
-      filter(it => !!it),
+      filter(it => it !== undefined) as OperatorFunction<Ohlc | undefined, Ohlc>,
       share()
     );
 }

package/src/domain/{candle.spec.ts → ohlc.spec.ts}

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

package/src/domain/{candle.ts → ohlc.ts}

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

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

@@ -3,20 +3,23 @@ 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, d(-100)))
+    new BehaviorSubject<Component>(new Order(0, '1', instrument, d(-100), 0))
       .pipe(order(instrument))
       .subscribe({
         next: it => {
@@ -42,9 +45,9 @@ describe('positions', () => {
   beforeEach(() => {
     state = new State();
 
-    order1 = Order.market(instrument, d(-100));
-    order2 = Order.limit(instrument, d(100), d(10));
-    order3 = Order.market(instrument, d(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,44 +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, d(100));
+    const sut = new Order(0, '1', instrument, d(100), 0);
 
     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));
+    const sut = new Order(0, '1', instrument, d(-100), 0);
 
     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));
+    const sut = new Order(0, '1', instrument, d(100), 0, 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));
+    const sut = new Order(0, '1', instrument, d(-100), 0, 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,12 +1,9 @@
-import { v4 } from 'uuid';
-
-import { d, decimal, 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,45 +13,17 @@ export type OrderState =
   | 'REJECTED';
 
 export class Order implements Component {
-  kind = 'order';
-  timestamp: timestamp;
-  id = v4();
-  externalId: string;
   state: OrderState = 'NEW';
-
   quantityExecuted = d.Zero;
-  averageExecutionRate: decimal;
-  createdAt: timestamp;
-
-  static market(instrument: InstrumentSelector, quantity: decimal): Order {
-    return new Order(instrument, 'MARKET', quantity);
-  }
-
-  static limit(instrument: InstrumentSelector, quantity: decimal, rate: decimal): Order {
-    return new Order(instrument, 'LIMIT', quantity, rate);
-  }
-
-  static stopMarket(
-    instrument: InstrumentSelector,
-    quantity: decimal,
-    stopRate: decimal
-  ): Order {
-    return new Order(instrument, 'STOP-MARKET', quantity, undefined, stopRate);
-  }
-
-  static stopLimit(
-    instrument: InstrumentSelector,
-    quantity: decimal,
-    rate: decimal,
-    stopRate: decimal
-  ): Order {
-    return new Order(instrument, 'STOP-LIMIT', quantity, rate, stopRate);
-  }
+  averageExecutionRate?: decimal;
+  externalId?: string;
 
   constructor(
-    readonly instrument: InstrumentSelector,
-    readonly type: OrderType,
+    public timestamp: number,
+    readonly id: string,
+    readonly instrument: Instrument,
     readonly quantity: decimal,
+    public createdAt: number,
     readonly rate?: decimal,
     readonly stopRate?: decimal
   ) {
@@ -67,29 +36,23 @@ export class Order implements Component {
     }
   }
 
-  toString() {
-    return this.id;
-  }
-
   calculateBalanceToLock(
     base: Balance,
     quote: Balance
-  ): { base: decimal; quote: decimal } {
+  ): { 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.rate) {
+        return {
+          base: d.Zero,
+          quote: quote.asset.ceil(this.rate.mul(qty))
+        };
+      } else {
+        return {
+          base: d.Zero,
+          quote: quote.free
+        };
       }
     }
 
@@ -99,5 +62,7 @@ export class Order implements Component {
         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,11 +1,11 @@
 import { Instrument } from '../domain';
-import { decimal, timestamp } from '../shared';
+import { decimal } from '../shared';
 import { Component } from './component';
 
 export interface Liquidity {
   rate: decimal;
   quantity: decimal;
-  next: this;
+  next: this | undefined;
 }
 
 export const LiquidityAskComparer = (lhs: { rate: decimal }, rhs: { rate: decimal }) =>
@@ -17,18 +17,14 @@ export const LiquidityBidComparer = (lhs: { rate: decimal }, rhs: { rate: decima
  * Provides an access to pending buy and sell orders on the specific market.
  */
 export class Orderbook implements Component {
-  id: string;
-  kind = 'orderbook';
-  timestamp: timestamp;
+  readonly id: string;
 
-  asks: Liquidity;
-  bids: Liquidity;
-
-  constructor(public readonly instrument: Instrument) {
+  constructor(
+    public timestamp: number,
+    public readonly instrument: Instrument,
+    public asks: Liquidity,
+    public bids: Liquidity
+  ) {
     this.id = instrument.id;
   }
-
-  toString() {
-    return this.instrument.toString();
-  }
 }