@quantform/core 0.5.14 → 0.5.15

package/src/domain/candle.operator.ts

@@ -0,0 +1,106 @@
+import {
+  concat,
+  filter,
+  last,
+  map,
+  mergeMap,
+  Observable,
+  share,
+  skipLast,
+  switchMap
+} from 'rxjs';
+
+import { Candle } from './candle';
+import { tf } from './timeframe';
+
+function aggregate(candle: Candle, timeframe: number, value: number, timestamp: number) {
+  const frame = tf(timestamp, timeframe);
+
+  if (!candle) {
+    return new Candle(frame, value, value, value, value);
+  }
+
+  if (candle.timestamp === frame) {
+    candle.apply(value);
+  } else {
+    return new Candle(frame, candle.close, value, value, value);
+  }
+}
+
+export function candle<T extends { timestamp: number }>(
+  timeframe: number,
+  fn: (x: T) => number,
+  candleToStartWith: Candle = undefined
+) {
+  return function (source: Observable<T>): Observable<Candle> {
+    let candle = candleToStartWith;
+
+    return source.pipe(
+      map(it => {
+        const newCandle = aggregate(candle, timeframe, fn(it), it.timestamp);
+        if (newCandle) {
+          const prevCandle = candle;
+          candle = newCandle;
+
+          if (candleToStartWith && candleToStartWith.timestamp < newCandle.timestamp) {
+            candleToStartWith = undefined;
+            return [prevCandle, candle];
+          }
+        }
+
+        if (candleToStartWith) {
+          candleToStartWith = undefined;
+        }
+
+        return [candle];
+      }),
+      mergeMap(it => it),
+      share()
+    );
+  };
+}
+
+export function mergeCandle<T extends { timestamp: number }>(
+  timeframe: number,
+  fn: (x: T) => number,
+  history$: Observable<Candle>
+) {
+  return function (source$: Observable<T>): Observable<Candle> {
+    return concat(
+      history$.pipe(skipLast(1)),
+      history$.pipe(
+        last(),
+        switchMap(lastHistoricalCandle =>
+          source$.pipe(candle(timeframe, fn, lastHistoricalCandle))
+        ),
+        share()
+      )
+    );
+  };
+}
+
+export function candleCompleted(): (source: Observable<Candle>) => Observable<Candle> {
+  let currCandle: Candle;
+
+  return (source: Observable<Candle>) =>
+    source.pipe(
+      map(it => {
+        if (!currCandle) {
+          currCandle = it;
+
+          return undefined;
+        } else {
+          if (currCandle.timestamp !== it.timestamp) {
+            const prevCandle = currCandle;
+            currCandle = it;
+
+            return prevCandle;
+          }
+
+          return undefined;
+        }
+      }),
+      filter(it => !!it),
+      share()
+    );
+}

package/src/domain/candle.spec.ts

@@ -1,13 +1,8 @@
-import { from, map } from 'rxjs';
-
 import { now } from '../shared';
-import { TradePatchEvent } from '../store';
-import { Candle, mergeCandle } from './candle';
-import { instrumentOf } from './instrument';
-import { Timeframe } from './timeframe';
+import { Candle } from './candle';
 
-describe('candle tests', () => {
-  test('should instantiate valid candle', () => {
+describe('Candle', () => {
+  test('should construct a candle', () => {
     const timestamp = now();
 
     const sut = new Candle(timestamp, 2, 4, 1, 3);
@@ -19,67 +14,16 @@ describe('candle tests', () => {
     expect(sut.close).toEqual(3);
   });
 
-  test('should pipe and merge candle from history', done => {
-    const timestamp = 0;
-    const instrument = instrumentOf('binance:btc-usdt');
-
-    const history$ = from([
-      new Candle(timestamp + Timeframe.D1 * 1, 1, 1.5, 0.5, 2),
-      new Candle(timestamp + Timeframe.D1 * 2, 2, 2.5, 1.5, 3),
-      new Candle(timestamp + Timeframe.D1 * 3, 3, 3.5, 2.5, 4)
-    ]);
-
-    const input$ = from([
-      new TradePatchEvent(instrument, 5, 1, timestamp + Timeframe.D1 * 3),
-      new TradePatchEvent(instrument, 3, 1, timestamp + Timeframe.D1 * 4),
-      new TradePatchEvent(instrument, 4, 1, timestamp + Timeframe.D1 * 5)
-    ]);
-
-    const high = [1.5, 2.5, 5, 3];
-
-    input$
-      .pipe(mergeCandle(Timeframe.D1, it => it.rate, history$))
-      .pipe(
-        map(it => {
-          expect(it.high).toBe(high.shift());
-
-          if (!high.length) {
-            done();
-          }
-        })
-      )
-      .subscribe();
-  });
-
-  test('should pipe and not merge candle from history', done => {
-    const timestamp = 0;
-    const instrument = instrumentOf('binance:btc-usdt');
-
-    const history$ = from([
-      new Candle(timestamp + Timeframe.D1 * 1, 1, 1.5, 0.5, 2),
-      new Candle(timestamp + Timeframe.D1 * 2, 2, 2.5, 1.5, 3),
-      new Candle(timestamp + Timeframe.D1 * 3, 3, 3.5, 2.5, 4)
-    ]);
-
-    const input$ = from([
-      new TradePatchEvent(instrument, 5, 1, timestamp + Timeframe.D1 * 4),
-      new TradePatchEvent(instrument, 3, 1, timestamp + Timeframe.D1 * 5),
-      new TradePatchEvent(instrument, 4, 1, timestamp + Timeframe.D1 * 6)
-    ]);
-
-    const high = [1.5, 2.5, 3.5, 5, 3];
+  test('should modify a candle', () => {
+    const timestamp = now();
 
-    input$
-      .pipe(mergeCandle(Timeframe.D1, it => it.rate, history$))
-      .pipe(
-        map(it => {
-          expect(it.high).toBe(high.shift());
+    const sut = new Candle(timestamp, 2, 4, 1, 3);
+    sut.apply(10);
 
-          if (!high.length) {
-            done();
-          }
-        })
-      )
-      .subscribe();
+    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);
   });
 });

package/src/domain/candle.ts

@@ -1,17 +1,4 @@
-import {
-  concat,
-  filter,
-  last,
-  map,
-  mergeMap,
-  Observable,
-  share,
-  skipLast,
-  withLatestFrom
-} from 'rxjs';
-
 import { timestamp } from '../shared';
-import { tf } from './timeframe';
 
 export class Candle {
   constructor(
@@ -19,7 +6,8 @@ export class Candle {
     public open: number,
     public high: number,
     public low: number,
-    public close: number
+    public close: number,
+    public volume?: number
   ) {}
 
   apply(value: number) {
@@ -28,103 +16,3 @@ export class Candle {
     this.close = value;
   }
 }
-
-export class CandleBuilder {
-  private current: Candle;
-
-  get candle(): Candle {
-    return this.current;
-  }
-
-  constructor(readonly timeframe: number) {}
-
-  append(value: number, timestamp: timestamp): Candle {
-    const frame = tf(timestamp, this.timeframe);
-
-    if (!this.current) {
-      this.current = new Candle(frame, value, value, value, value);
-
-      return null;
-    }
-
-    if (this.candle.timestamp == frame) {
-      this.candle.apply(value);
-
-      return null;
-    }
-
-    const previous = this.current;
-
-    this.current = new Candle(frame, value, value, value, value);
-    return previous;
-  }
-}
-
-export function candle<T extends { timestamp: number }>(
-  timeframe: number,
-  fn: (x: T) => number,
-  options: { passThru: boolean } = { passThru: false }
-) {
-  return function (source: Observable<T>): Observable<Candle> {
-    const builder = new CandleBuilder(timeframe);
-    let candle: Candle;
-
-    if (options.passThru) {
-      return source.pipe(
-        map(it => {
-          builder.append(fn(it), it.timestamp);
-          return builder.candle;
-        }),
-        share()
-      );
-    }
-
-    return source.pipe(
-      filter(it => (candle = builder.append(fn(it), it.timestamp)) != null),
-      map(_ => candle),
-      share()
-    );
-  };
-}
-
-export function mergeCandle<T extends { timestamp: number }>(
-  timeframe: number,
-  fn: (x: T) => number,
-  history$: Observable<Candle>
-) {
-  return function (source$: Observable<T>): Observable<Candle> {
-    const builder = new CandleBuilder(timeframe);
-    let hasMergedHistory = false;
-
-    return concat(
-      history$.pipe(skipLast(1)),
-      source$.pipe(
-        withLatestFrom(history$.pipe(last())),
-        mergeMap(([it, history]) => {
-          const completed = builder.append(fn(it), it.timestamp);
-
-          if (completed) {
-            if (completed.timestamp == history.timestamp) {
-              completed.open = history.open;
-              completed.high = Math.max(completed.high, history.high);
-              completed.low = Math.min(completed.low, history.low);
-
-              hasMergedHistory = true;
-            } else if (completed.timestamp > history.timestamp) {
-              if (!hasMergedHistory) {
-                hasMergedHistory = true;
-                return [history, completed];
-              }
-            } else if (completed.timestamp < history.timestamp) {
-              throw new Error('invalid candle sequence, input data is to old.');
-            }
-
-            return [completed];
-          }
-
-          return [];
-        })
-      )
-    );
-  };
-}

package/src/domain/commission.spec.ts

@@ -0,0 +1,33 @@
+import { commissionPercentOf } from './commission';
+
+describe('Commission', () => {
+  test('should construct a Commission', () => {
+    const sut = commissionPercentOf({
+      maker: 0.1,
+      taker: 0.2
+    });
+
+    expect(sut.makerRate).toEqual(0.001);
+    expect(sut.takerRate).toEqual(0.002);
+  });
+
+  test('should calculate a maker fee', () => {
+    const sut = commissionPercentOf({
+      maker: 0.1,
+      taker: 0.2
+    });
+
+    expect(sut.calculateMakerFee(2000)).toEqual(2);
+    expect(sut.applyMakerFee(2000)).toEqual(1998);
+  });
+
+  test('should calculate a taker fee', () => {
+    const sut = commissionPercentOf({
+      maker: 0.1,
+      taker: 0.2
+    });
+
+    expect(sut.calculateTakerFee(2000)).toEqual(4);
+    expect(sut.applyTakerFee(2000)).toEqual(1996);
+  });
+});

package/src/domain/commission.ts

@@ -18,6 +18,6 @@ export class Commission {
   }
 }
 
-export function commissionPercentOf(maker: number, taker: number) {
-  return new Commission(maker / 100.0, taker / 100.0);
+export function commissionPercentOf(fees: { maker: number; taker: number }) {
+  return new Commission(fees.maker / 100.0, fees.taker / 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,25 @@
+export function insufficientFundsError(
+  assetName: string,
+  requiredAmount: number,
+  availableAmount: number
+) {
+  return new Error(
+    `insufficient funds of ${assetName} has: ${availableAmount} requires: ${requiredAmount}`
+  );
+}
+
+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);
 }