@quantform/core 0.5.14 → 0.5.15

package/src/cli/pull.ts

@@ -40,10 +40,12 @@ export default async function (name: string, instrument: string, options: any) {
     );
   }
 
+  console.time('Pulling completed in');
+
   await session.awake(undefined);
 
   const bar = new SingleBar({}, Presets.shades_classic);
-  const feed = new Feed(module.descriptor.storage.create('feed'));
+  const feed = new Feed(module.descriptor.storage('feed'));
 
   bar.start(100, 0);
 
@@ -64,4 +66,6 @@ export default async function (name: string, instrument: string, options: any) {
   bar.stop();
 
   await session.dispose();
+
+  console.timeLog('Pulling completed in');
 }

package/src/cli/test.ts

@@ -1,4 +1,3 @@
-import { BacktesterStreamer } from '../adapter';
 import { Bootstrap } from '../bootstrap';
 import build from './build';
 import { getModule } from './internal/workspace';
@@ -36,10 +35,14 @@ export default async function (name, options: any) {
 
   await new Promise<void>(async resolve => {
     const [session] = bootstrap.useBacktestPeriod(from, to).backtest({
+      onBacktestStarted: () => {
+        console.log('backtest started');
+        console.time('backtest completed');
+      },
       onBacktestCompleted: async () => {
         await session.dispose();
 
-        console.log('backtest completed.');
+        console.timeEnd('backtest completed');
 
         resolve();
       }

package/src/domain/asset.spec.ts

@@ -1,66 +1,70 @@
 import { Asset, assetOf } from './asset';
 
-describe('asset tests', () => {
-  test('should instantiate proper asset', () => {
+describe('Asset', () => {
+  test('should construct a new asset', () => {
     const sut = new Asset('abc', 'xyz', 4);
 
     expect(sut.name).toEqual('abc');
-    expect(sut.adapter).toEqual('xyz');
+    expect(sut.adapterName).toEqual('xyz');
     expect(sut.scale).toEqual(4);
     expect(sut.tickSize).toEqual(0.0001);
     expect(sut.fixed(1.1234567)).toEqual(1.1234);
     expect(sut.floor(1.1234567)).toEqual(1.1234);
     expect(sut.ceil(1.1234567)).toEqual(1.1235);
-    expect(sut.toString()).toEqual('xyz:abc');
+    expect(sut.id).toEqual('xyz:abc');
+  });
+
+  test('should throw for missing asset name', () => {
+    const fn = () => new Asset('xyz', '', 5);
+
+    expect(fn).toThrowError();
+  });
+
+  test('should throw for missing adapter name', () => {
+    const fn = () => new Asset('', 'xyz', 5);
+
+    expect(fn).toThrowError();
   });
 });
 
-describe('asset selector tests', () => {
-  test('should instantiate proper asset selector', () => {
+describe('AssetSelector', () => {
+  test('should construct a new asset selector from unified string', () => {
     const sut = assetOf('xyz:abc');
 
     expect(sut.name).toEqual('abc');
-    expect(sut.adapter).toEqual('xyz');
-    expect(sut.toString()).toEqual('xyz:abc');
+    expect(sut.adapterName).toEqual('xyz');
+    expect(sut.id).toEqual('xyz:abc');
   });
 
   test('should instantiate proper asset selector capital case', () => {
     const sut = assetOf('XYZ:ABC');
 
     expect(sut.name).toEqual('abc');
-    expect(sut.adapter).toEqual('xyz');
-    expect(sut.toString()).toEqual('xyz:abc');
+    expect(sut.adapterName).toEqual('xyz');
+    expect(sut.id).toEqual('xyz:abc');
   });
 
   test('should throw invalid format message for missing separator', () => {
-    const fn = () => {
-      assetOf('xyzabc');
-    };
+    const fn = () => assetOf('xyzabc');
 
-    expect(fn).toThrow(Error);
+    expect(fn).toThrowError();
   });
 
-  test('should throw invalid format message for multiple separators', () => {
-    const fn = () => {
-      assetOf('xyz:abc:');
-    };
+  test('should throw for multiple separators', () => {
+    const fn = () => assetOf('xyz:abc:');
 
-    expect(fn).toThrow(Error);
+    expect(fn).toThrowError();
   });
 
-  test('should throw invalid format message for missing asset name', () => {
-    const fn = () => {
-      assetOf('xyz:');
-    };
+  test('should throw for missing asset name', () => {
+    const fn = () => assetOf('xyz:');
 
-    expect(fn).toThrow(Error);
+    expect(fn).toThrowError();
   });
 
-  test('should throw invalid format message for missing adapter name', () => {
-    const fn = () => {
-      assetOf(':abc');
-    };
+  test('should throw for missing adapter name', () => {
+    const fn = () => assetOf(':abc');
 
-    expect(fn).toThrow(Error);
+    expect(fn).toThrowError();
   });
 });

package/src/domain/asset.ts

@@ -1,19 +1,28 @@
 import { ceil, fixed, floor } from '../shared/decimals';
+import { invalidArgumentError, invalidAssetSelectorError } from './error';
+
+export const AssetSelectorSeparator = ':';
 
 /**
  * Supposed to query specific @see Asset from based on string notation.
  */
 export class AssetSelector {
-  private readonly id: string;
-
+  readonly id: string;
   readonly name: string;
-  readonly adapter: string;
+  readonly adapterName: string;
 
-  constructor(name: string, adapter: string) {
-    this.name = name.toLowerCase();
-    this.adapter = adapter.toLowerCase();
+  constructor(name: string, adapterName: string) {
+    if (!name?.length) {
+      throw invalidArgumentError(name);
+    }
 
-    this.id = `${this.adapter}:${this.name}`;
+    if (!adapterName?.length) {
+      throw invalidArgumentError(adapterName);
+    }
+
+    this.name = name.toLowerCase();
+    this.adapterName = adapterName.toLowerCase();
+    this.id = `${this.adapterName}${AssetSelectorSeparator}${this.name}`;
   }
 
   /**
@@ -27,21 +36,14 @@ export class AssetSelector {
 /**
  * Creates @see AssetSelector based on unified string notation.
  */
-export function assetOf(asset: string): AssetSelector {
-  const section = asset.split(':');
+export function assetOf(selector: string): AssetSelector {
+  const [adapterName, name, ...rest] = selector.split(AssetSelectorSeparator);
 
-  if (section.length != 2) {
-    throw Error('invalid asset format');
+  if (!adapterName || !name || rest.length) {
+    throw invalidAssetSelectorError(selector);
   }
 
-  const assetName = section[1];
-  const adapterName = section[0];
-
-  if (assetName.length == 0 || adapterName.length == 0) {
-    throw Error('invalid asset format');
-  }
-
-  return new AssetSelector(assetName, adapterName);
+  return new AssetSelector(name, adapterName);
 }
 
 /**
@@ -51,8 +53,12 @@ export function assetOf(asset: string): AssetSelector {
 export class Asset extends AssetSelector {
   readonly tickSize: number;
 
-  constructor(name: string, adapter: string, public readonly scale: number) {
-    super(name, adapter);
+  constructor(name: string, adapterName: string, public readonly scale: number) {
+    super(name, adapterName);
+
+    if (scale && (scale < 0 || Number.isNaN(scale))) {
+      throw invalidArgumentError(scale);
+    }
 
     this.tickSize = 1.0 / Math.pow(10, this.scale);
   }

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

@@ -0,0 +1,25 @@
+import { Subject } from 'rxjs';
+
+import { State } from '../store';
+import { Asset } from './asset';
+import { Balance } from './balance';
+import { balance } from './balance.operator';
+import { Component } from './component';
+
+describe('balance', () => {
+  const asset = new Asset('abc', 'xyz', 4);
+  const state = new State();
+
+  beforeEach(() => {
+    state.balance.upsert(new Balance(asset));
+  });
+
+  test('should pipe a balance on subscription', done => {
+    new Subject<Component>().pipe(balance(asset, state)).subscribe({
+      next: it => {
+        expect(it.asset).toEqual(asset);
+        done();
+      }
+    });
+  });
+});

package/src/domain/balance.operator.ts

@@ -0,0 +1,15 @@
+import { filter, map, Observable, startWith } from 'rxjs';
+
+import { State } from '../store';
+import { AssetSelector } from './asset';
+import { Balance } from './balance';
+import { Component } from './component';
+
+export function balance(selector: AssetSelector, state: State) {
+  return (source$: Observable<Component>) =>
+    source$.pipe(
+      startWith(state.balance.get(selector.id)),
+      filter(it => it instanceof Balance && (!selector || it.asset.id == selector.id)),
+      map(it => it as Balance)
+    );
+}

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.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.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,17 +1,18 @@
 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 locker: Record<string, number> = {};
   private available = 0;
   private unavailable = 0;
 
@@ -19,11 +20,7 @@ export class Balance implements Component {
    * Returns available amount to trade.
    */
   get free(): number {
-    return (
-      this.available +
-      this.getEstimatedUnrealizedPnL('CROSS') -
-      this.getEstimatedMaintenanceMargin('CROSS')
-    );
+    return this.asset.fixed(this.available) + this.getEstimatedUnrealizedPnL('CROSS');
   }
 
   /**
@@ -39,56 +36,69 @@ export class Balance implements Component {
    */
   get total(): number {
     return (
-      this.available + this.unavailable + 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) {
+  account(amount: number) {
     if (this.available + amount < 0) {
-      throw new Error(`invalid balance amount has: ${this.available} wants: ${amount}`);
+      throw insufficientFundsError(this.id, amount, this.available);
     }
 
     this.available += amount;
   }
 
-  set(free: number, freezed: number) {
-    if (free != null) {
-      this.available = free;
-    }
-
-    if (freezed != null) {
-      this.unavailable = 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) {
+  lock(id: string, amount: number) {
     if (this.available < amount) {
-      throw new Error(`insufficient funds has: ${this.available} wants: ${amount}`);
+      throw insufficientFundsError(this.id, amount, this.available);
+    }
+
+    if (this.locker[id]) {
+      throw invalidArgumentError(id);
     }
 
+    this.locker[id] = amount;
     this.available -= amount;
     this.unavailable += 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;
+
+    return true;
   }
 
   /**
@@ -111,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();
+        }
+      }
+    });
+  });
+});