@quantform/core 0.4.11 → 0.5.15

package/src/domain/balance.spec.ts

@@ -1,24 +1,112 @@
 import { Asset } from './asset';
 import { Balance } from './balance';
+import { Instrument } from './instrument';
+import { Position } from './position';
 
-describe('balance tests', () => {
-  test('should instantiate empty balance', () => {
-    const sut = new Balance(new Asset('abc', 'xyz', 4));
+describe('Balance', () => {
+  const asset = new Asset('abc', 'xyz', 4);
+  const instrument = new Instrument(
+    new Asset('abc', 'xyz', 4),
+    new Asset('def', 'xyz', 4),
+    'abc-def'
+  );
 
-    expect(sut.asset.toString()).toEqual('xyz:abc');
+  test('should construct empty balance', () => {
+    const sut = new Balance(asset);
+
+    expect(sut.asset.id).toEqual('xyz:abc');
     expect(sut.free).toEqual(0);
-    expect(sut.freezed).toEqual(0);
+    expect(sut.locked).toEqual(0);
     expect(Object.keys(sut.position).length).toEqual(0);
   });
 
-  test('should instantiate balance', () => {
-    const sut = new Balance(new Asset('abc', 'xyz', 4));
+  test('should construct balance', () => {
+    const sut = new Balance(asset);
 
     sut.set(100, 50);
 
-    expect(sut.asset.toString()).toEqual('xyz:abc');
+    expect(sut.asset.id).toEqual('xyz:abc');
     expect(sut.free).toEqual(100);
-    expect(sut.freezed).toEqual(50);
+    expect(sut.locked).toEqual(50);
+    expect(sut.total).toEqual(150);
     expect(Object.keys(sut.position).length).toEqual(0);
   });
+
+  test('should account positive amount', () => {
+    const sut = new Balance(asset);
+
+    sut.set(100, 0);
+    sut.account(10);
+
+    expect(sut.free).toEqual(110);
+    expect(sut.locked).toEqual(0);
+    expect(sut.total).toEqual(110);
+  });
+
+  test('should account negative amount', () => {
+    const sut = new Balance(asset);
+
+    sut.set(100, 0);
+    sut.account(-10);
+
+    expect(sut.free).toEqual(90);
+    expect(sut.locked).toEqual(0);
+    expect(sut.total).toEqual(90);
+  });
+
+  test('should throw for insufficient balance account amount', () => {
+    const sut = new Balance(asset);
+
+    sut.set(100, 0);
+    const fn = () => sut.account(-120);
+
+    expect(fn).toThrowError();
+  });
+
+  test('should lock specific amount of available balance', () => {
+    const sut = new Balance(asset);
+
+    sut.set(100, 0);
+    sut.lock('key', 10);
+
+    expect(sut.free).toEqual(90);
+    expect(sut.locked).toEqual(10);
+    expect(sut.total).toEqual(100);
+  });
+
+  test('should throw for lock insufficient amount of available balance', () => {
+    const sut = new Balance(asset);
+
+    sut.set(30, 50);
+    const fn = () => sut.lock('key', 100);
+
+    expect(fn).toThrowError();
+  });
+
+  test('should lock an unlock specific amount of available balance', () => {
+    const sut = new Balance(asset);
+
+    sut.set(100, 0);
+    sut.lock('key', 40);
+    sut.tryUnlock('key');
+
+    expect(sut.free).toEqual(100);
+    expect(sut.locked).toEqual(0);
+    expect(sut.total).toEqual(100);
+  });
+
+  test('should return correct estimated unrealized pnl', () => {
+    const position = new Position('1', instrument, 'CROSS', 2511.81, 10.31, 20);
+
+    position.calculateEstimatedUnrealizedPnL(2576.44);
+
+    const sut = new Balance(asset);
+
+    sut.set(100, 0);
+    sut.position['1'] = position;
+
+    expect(sut.getEstimatedUnrealizedPnL()).toEqual(0.2652);
+    expect(sut.free).toEqual(100 + 0.2652);
+    expect(sut.total).toEqual(100 + 0.2652);
+  });
 });

package/src/domain/balance.ts

@@ -1,35 +1,33 @@
 import { 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 _free = 0;
-  private _freezed = 0;
+  private locker: Record<string, number> = {};
+  private available = 0;
+  private unavailable = 0;
 
   /**
    * Returns available amount to trade.
    */
   get free(): number {
-    return (
-      this._free +
-      this.getEstimatedUnrealizedPnL('CROSS') -
-      this.getEstimatedMaintenanceMargin('CROSS')
-    );
+    return this.asset.fixed(this.available) + this.getEstimatedUnrealizedPnL('CROSS');
   }
 
   /**
    * Return locked amount for order.
    */
-  get freezed(): number {
-    return this._freezed;
+  get locked(): number {
+    return this.unavailable;
   }
 
   /**
@@ -38,56 +36,69 @@ export class Balance implements Component {
    */
   get total(): number {
     return (
-      this._free + this._freezed + this.getEstimatedUnrealizedPnL() /* +
-      this.getEstimatedMaintenanceMargin()*/
+      this.asset.fixed(this.available + this.unavailable) +
+      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._free + amount < 0) {
-      throw new Error(`invalid balance amount has: ${this._free} wants: ${amount}`);
+  account(amount: number) {
+    if (this.available + amount < 0) {
+      throw insufficientFundsError(this.id, amount, this.available);
     }
 
-    this._free += amount;
+    this.available += amount;
   }
 
-  set(free: number, freezed: number) {
-    if (free != null) {
-      this._free = free;
-    }
-
-    if (freezed != null) {
-      this._freezed = freezed;
-    }
+  set(free: number, locked: number) {
+    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._free < amount) {
-      throw new Error(`insufficient funds has: ${this._free} wants: ${amount}`);
+  lock(id: string, amount: number) {
+    if (this.available < amount) {
+      throw insufficientFundsError(this.id, amount, this.available);
+    }
+
+    if (this.locker[id]) {
+      throw invalidArgumentError(id);
     }
 
-    this._free -= amount;
-    this._freezed += amount;
+    this.locker[id] = amount;
+    this.available -= amount;
+    this.unavailable += amount;
   }
 
-  unfreez(amount: number) {
-    if (this._freezed < amount) {
-      throw new Error(`insufficient funds has: ${this._freezed} wants: ${amount}`);
+  tryUnlock(id: string): boolean {
+    if (!this.locker[id]) {
+      return false;
+    }
+
+    const amount = this.locker[id];
+
+    delete this.locker[id];
+
+    if (this.unavailable < amount) {
+      throw insufficientFundsError(this.id, amount, this.unavailable);
     }
 
-    this._free += amount;
-    this._freezed -= amount;
+    this.available += amount;
+    this.unavailable -= amount;
+
+    return true;
   }
 
   /**
@@ -110,10 +121,6 @@ export class Balance implements Component {
     );
   }
 
-  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,125 @@
+import { from } from 'rxjs';
+
+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: 1 },
+      { timestamp: 2, rate: 2 },
+      { timestamp: 3, rate: 3 },
+      { timestamp: 4, rate: 0 },
+      { timestamp: 5, rate: 7 },
+      { timestamp: 6, rate: 8 }
+    ]);
+
+    const output = [
+      { timestamp: 0, open: 1, high: 1, low: 1, close: 1 },
+      { timestamp: 0, open: 1, high: 2, low: 1, close: 2 },
+      { timestamp: 0, open: 1, high: 3, low: 1, close: 3 },
+      { timestamp: 0, open: 1, high: 3, low: 0, close: 0 },
+      { timestamp: 5, open: 0, high: 7, low: 7, close: 7 },
+      { timestamp: 5, open: 0, high: 8, low: 7, close: 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: 1 },
+      { timestamp: 2, rate: 2 },
+      { timestamp: 3, rate: 3 },
+      { timestamp: 4, rate: 0 },
+      { timestamp: 5, rate: 7 },
+      { timestamp: 6, rate: 8 }
+    ]);
+
+    input$
+      .pipe(
+        candle(5, it => it.rate),
+        candleCompleted()
+      )
+      .subscribe({
+        next: it => {
+          expect(it).toEqual({ timestamp: 0, open: 1, high: 3, low: 0, close: 0 });
+          done();
+        }
+      });
+  });
+});
+
+describe('mergeCandle', () => {
+  test('should pipe and merge candle from history', done => {
+    const history$ = from([
+      new Candle(1, 1, 1.5, 0.5, 2),
+      new Candle(2, 2, 2.5, 1.5, 3),
+      new Candle(3, 3, 3.5, 2.5, 4)
+    ]);
+
+    const input$ = from([
+      { timestamp: 3, rate: 5 },
+      { timestamp: 4, rate: 3 },
+      { timestamp: 5, rate: 4 }
+    ]);
+
+    const output = [
+      { timestamp: 1, open: 1, high: 1.5, low: 0.5, close: 2 },
+      { timestamp: 2, open: 2, high: 2.5, low: 1.5, close: 3 },
+      { timestamp: 3, open: 3, high: 5, low: 2.5, close: 5 },
+      { timestamp: 4, open: 5, high: 3, low: 3, close: 3 },
+      { timestamp: 5, open: 3, high: 4, low: 4, close: 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, 1, 1.5, 0.5, 2),
+      new Candle(2, 2, 2.5, 1.5, 3),
+      new Candle(3, 3, 3.5, 2.5, 4)
+    ]);
+
+    const input$ = from([
+      { timestamp: 4, rate: 5 },
+      { timestamp: 5, rate: 3 },
+      { timestamp: 6, rate: 4 }
+    ]);
+
+    const output = [
+      { timestamp: 1, open: 1, high: 1.5, low: 0.5, close: 2 },
+      { timestamp: 2, open: 2, high: 2.5, low: 1.5, close: 3 },
+      { timestamp: 3, open: 3, high: 3.5, low: 2.5, close: 4 },
+      { timestamp: 4, open: 4, high: 5, low: 5, close: 5 },
+      { timestamp: 5, open: 5, high: 3, low: 3, close: 3 },
+      { timestamp: 6, open: 3, high: 4, low: 4, close: 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,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,12 +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);
@@ -18,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);
   });
 });