@quantform/core 0.4.11 → 0.5.15

package/src/domain/candle.ts

@@ -1,16 +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(
@@ -18,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) {
@@ -27,94 +16,3 @@ export class Candle {
     this.close = value;
   }
 }
-
-export class CandleBuilder {
-  private _candle: Candle;
-
-  get candle(): Candle {
-    return this._candle;
-  }
-
-  constructor(readonly timeframe: number) {}
-
-  append(value: number, timestamp: timestamp): Candle {
-    const frame = tf(timestamp, this.timeframe);
-
-    if (!this._candle) {
-      this._candle = new Candle(frame, value, value, value, value);
-
-      return null;
-    }
-
-    if (this.candle.timestamp == frame) {
-      this.candle.apply(value);
-
-      return null;
-    }
-
-    const previous = this._candle;
-
-    this._candle = new Candle(frame, value, value, value, value);
-    return previous;
-  }
-}
-
-export function candle<T extends { timestamp: number }>(
-  timeframe: number,
-  fn: (x: T) => number
-) {
-  return function (source: Observable<T>): Observable<Candle> {
-    const builder = new CandleBuilder(timeframe);
-    let candle: Candle;
-
-    return source.pipe(
-      filter(it => {
-        return (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,5 +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 {
@@ -25,23 +27,31 @@ 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) {
-    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,81 @@
+import { BehaviorSubject, map, Subject } from 'rxjs';
+
+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, -100))
+      .pipe(order(instrument))
+      .subscribe({
+        next: it => {
+          expect(it.instrument).toEqual(instrument);
+          expect(it.quantity).toEqual(-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, -100);
+    order2 = Order.limit(instrument, 100, 10);
+    order3 = Order.market(instrument, 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,43 @@
+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, 100);
+
+    expect(sut.quantity).toEqual(100);
+    expect(sut.rate).toEqual(undefined);
+    expect(sut.type).toEqual('MARKET');
+  });
+
+  test('should construct a market sell order', () => {
+    const sut = Order.market(instrument, -100);
+
+    expect(sut.quantity).toEqual(-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);
+
+    expect(sut.quantity).toEqual(100);
+    expect(sut.rate).toEqual(2000);
+    expect(sut.type).toEqual('LIMIT');
+  });
+
+  test('should construct a limit sell order', () => {
+    const sut = Order.limit(instrument, -100, 2000);
+
+    expect(sut.quantity).toEqual(-100);
+    expect(sut.rate).toEqual(2000);
+    expect(sut.type).toEqual('LIMIT');
+  });
+});