@quantform/core 0.5.13 → 0.5.23

package/src/domain/balance.ts

@@ -1,35 +1,32 @@
-import { timestamp } from '../shared';
+import { d, decimal, timestamp } from '../shared';
 import { Asset } from './';
 import { Component } from './component';
+import { insufficientFundsError, invalidArgumentError } from './error';
 import { Position, PositionMode } from './position';
 
 /**
  * Represents single asset balance in your wallet.
  */
 export class Balance implements Component {
+  id: string;
   kind = 'balance';
   timestamp: timestamp;
 
-  readonly maintenanceMarginRate = 1;
-
-  private available = 0;
-  private unavailable = 0;
+  private locker: Record<string, decimal> = {};
+  private available = d.Zero;
+  private unavailable = d.Zero;
 
   /**
    * Returns available amount to trade.
    */
-  get free(): number {
-    return (
-      this.available +
-      this.getEstimatedUnrealizedPnL('CROSS') -
-      this.getEstimatedMaintenanceMargin('CROSS')
-    );
+  get free(): decimal {
+    return this.asset.floor(this.available).add(this.getEstimatedUnrealizedPnL('CROSS'));
   }
 
   /**
    * Return locked amount for order.
    */
-  get locked(): number {
+  get locked(): decimal {
     return this.unavailable;
   }
 
@@ -37,84 +34,93 @@ export class Balance implements Component {
    * Return total amount of asset in wallet.
    * Represents a sum of free, locked and opened positions.
    */
-  get total(): number {
-    return (
-      this.available + this.unavailable + this.getEstimatedUnrealizedPnL() /* +
-      this.getEstimatedMaintenanceMargin()*/
-    );
+  get total(): decimal {
+    return this.asset
+      .floor(this.available.add(this.unavailable))
+      .add(this.getEstimatedUnrealizedPnL());
   }
 
   /**
    * Collection of opened positions backed by this balance.
    */
-  position: Record<string, Position> = {};
+  readonly position: Record<string, Position> = {};
 
-  constructor(public readonly asset: Asset) {}
+  constructor(public readonly asset: Asset) {
+    this.id = asset.id;
+  }
 
-  transact(amount: number) {
-    if (this.available + amount < 0) {
-      throw new Error(`invalid balance amount has: ${this.available} wants: ${amount}`);
+  account(amount: decimal) {
+    if (this.available.add(amount).lessThan(0)) {
+      throw insufficientFundsError(this.id, amount, this.available);
     }
 
-    this.available += amount;
+    this.available = this.available.add(amount);
   }
 
-  set(free: number, freezed: number) {
-    if (free != null) {
-      this.available = free;
-    }
-
-    if (freezed != null) {
-      this.unavailable = freezed;
-    }
+  set(free: decimal, locked: decimal) {
+    this.available = free;
+    this.unavailable = locked;
+    this.locker = {};
   }
 
   /**
    * Lock specific amount of asset.
    * If you place new pending order, you will lock your balance to fund order.
    */
-  freez(amount: number) {
-    if (this.available < amount) {
-      throw new Error(`insufficient funds has: ${this.available} wants: ${amount}`);
+  lock(id: string, amount: decimal) {
+    if (this.available.lessThan(amount)) {
+      throw insufficientFundsError(this.id, amount, this.available);
+    }
+
+    if (this.locker[id]) {
+      throw invalidArgumentError(id);
     }
 
-    this.available -= amount;
-    this.unavailable += amount;
+    this.locker[id] = amount;
+    this.available = this.available.minus(amount);
+    this.unavailable = this.unavailable.plus(amount);
   }
 
-  unfreez(amount: number) {
+  tryUnlock(id: string): boolean {
+    if (!this.locker[id]) {
+      return false;
+    }
+
+    const amount = this.locker[id];
+
+    delete this.locker[id];
+
     if (this.unavailable < amount) {
-      throw new Error(`insufficient funds has: ${this.unavailable} wants: ${amount}`);
+      throw insufficientFundsError(this.id, amount, this.unavailable);
     }
 
-    this.available += amount;
-    this.unavailable -= amount;
+    this.available = this.available.add(amount);
+    this.unavailable = this.unavailable.minus(amount);
+
+    return true;
   }
 
   /**
    * Returns unrealized profit and loss for all positions backed by this balance.
    */
-  getEstimatedUnrealizedPnL(mode?: PositionMode) {
+  getEstimatedUnrealizedPnL(mode?: PositionMode): decimal {
     return Object.values(this.position).reduce(
       (aggregate, position) =>
-        (aggregate +=
-          mode && mode != position.mode ? 0 : position.estimatedUnrealizedPnL),
-      0
+        (aggregate = aggregate.add(
+          mode && mode != position.mode ? 0 : position.estimatedUnrealizedPnL
+        )),
+      d.Zero
     );
   }
 
-  getEstimatedMargin(mode?: PositionMode): number {
+  getEstimatedMargin(mode?: PositionMode): decimal {
     return Object.values(this.position).reduce(
       (aggregate, position) =>
-        (aggregate += mode && mode != position.mode ? 0 : position.margin),
-      0
+        (aggregate = aggregate.add(mode && mode != position.mode ? 0 : position.margin)),
+      d.Zero
     );
   }
 
-  getEstimatedMaintenanceMargin(mode?: PositionMode): number {
-    return this.getEstimatedMargin(mode) * this.maintenanceMarginRate;
-  }
-
   toString() {
     return this.asset.toString();
   }

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

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

package/src/domain/candle.operator.ts

@@ -0,0 +1,107 @@
+import {
+  concat,
+  filter,
+  last,
+  map,
+  mergeMap,
+  Observable,
+  share,
+  skipLast,
+  switchMap
+} from 'rxjs';
+
+import { decimal } from '../shared';
+import { Candle } from './candle';
+import { tf } from './timeframe';
+
+function aggregate(candle: Candle, timeframe: number, value: decimal, 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) => decimal,
+  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) => decimal,
+  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,85 +1,30 @@
-import { from, map } from 'rxjs';
+import { d, now } from '../shared';
+import { Candle } from './candle';
 
-import { now } from '../shared';
-import { TradePatchEvent } from '../store';
-import { Candle, mergeCandle } from './candle';
-import { instrumentOf } from './instrument';
-import { Timeframe } from './timeframe';
-
-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);
+    const sut = new Candle(timestamp, d(2), d(4), d(1), d(3));
 
     expect(sut.timestamp).toEqual(timestamp);
-    expect(sut.open).toEqual(2);
-    expect(sut.high).toEqual(4);
-    expect(sut.low).toEqual(1);
-    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();
+    expect(sut.open).toEqual(d(2));
+    expect(sut.high).toEqual(d(4));
+    expect(sut.low).toEqual(d(1));
+    expect(sut.close).toEqual(d(3));
   });
 
-  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)
-    ]);
+  test('should modify a candle', () => {
+    const timestamp = now();
 
-    const high = [1.5, 2.5, 3.5, 5, 3];
+    const sut = new Candle(timestamp, d(2), d(4), d(1), d(3));
 
-    input$
-      .pipe(mergeCandle(Timeframe.D1, it => it.rate, history$))
-      .pipe(
-        map(it => {
-          expect(it.high).toBe(high.shift());
+    sut.apply(d(10));
 
-          if (!high.length) {
-            done();
-          }
-        })
-      )
-      .subscribe();
+    expect(sut.timestamp).toEqual(timestamp);
+    expect(sut.open).toEqual(d(2));
+    expect(sut.high).toEqual(d(10));
+    expect(sut.low).toEqual(d(1));
+    expect(sut.close).toEqual(d(10));
   });
 });

package/src/domain/candle.ts

@@ -1,130 +1,18 @@
-import {
-  concat,
-  filter,
-  last,
-  map,
-  mergeMap,
-  Observable,
-  share,
-  skipLast,
-  withLatestFrom
-} from 'rxjs';
-
-import { timestamp } from '../shared';
-import { tf } from './timeframe';
+import { decimal, timestamp } from '../shared';
 
 export class Candle {
   constructor(
     public timestamp: timestamp,
-    public open: number,
-    public high: number,
-    public low: number,
-    public close: number
+    public open: decimal,
+    public high: decimal,
+    public low: decimal,
+    public close: decimal,
+    public volume?: decimal
   ) {}
 
-  apply(value: number) {
-    this.high = Math.max(this.high, value);
-    this.low = Math.min(this.low, value);
+  apply(value: decimal) {
+    this.high = decimal.max(this.high, value);
+    this.low = decimal.min(this.low, value);
     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,34 @@
+import { d } from '../shared';
+import { commissionPercentOf } from './commission';
+
+describe('Commission', () => {
+  test('should construct a Commission', () => {
+    const sut = commissionPercentOf({
+      maker: d(0.1),
+      taker: d(0.2)
+    });
+
+    expect(sut.makerRate).toEqual(d(0.001));
+    expect(sut.takerRate).toEqual(d(0.002));
+  });
+
+  test('should calculate a maker fee', () => {
+    const sut = commissionPercentOf({
+      maker: d(0.1),
+      taker: d(0.2)
+    });
+
+    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: d(0.1),
+      taker: d(0.2)
+    });
+
+    expect(sut.calculateTakerFee(d(2000))).toEqual(d(4));
+    expect(sut.applyTakerFee(d(2000))).toEqual(d(1996));
+  });
+});