@quantform/core 0.5.13 → 0.5.23

package/src/bootstrap.ts

@@ -1,12 +1,13 @@
 import {
   AdapterAggregate,
-  BacktesterAdapter,
   BacktesterListener,
   BacktesterStreamer,
-  PaperAdapter
+  createBacktesterAdapterFactory,
+  createPaperAdapterFactory,
+  DefaultTimeProvider
 } from './adapter';
 import { Session, SessionDescriptor } from './domain';
-import { Cache, Feed, InMemoryStorage, InMemoryStorageFactory } from './storage';
+import { Cache, Feed, inMemoryStorageFactory } from './storage';
 import { Store } from './store';
 
 export class Bootstrap {
@@ -56,9 +57,9 @@ export class Bootstrap {
    */
   backtest(listener?: BacktesterListener): [Session, BacktesterStreamer] {
     const store = new Store();
-    const { storage } = this.descriptor;
-    const feed = new Feed(storage.create('feed'));
-    const cache = new Cache(storage.create('cache'));
+    const storage = this.descriptor.storage ?? inMemoryStorageFactory();
+    const feed = new Feed(storage('feed'));
+    const cache = new Cache(storage('cache'));
 
     const streamer = new BacktesterStreamer(
       store,
@@ -68,13 +69,13 @@ export class Bootstrap {
     );
 
     const aggregate = new AdapterAggregate(
-      this.descriptor.adapter.map(
-        it =>
-          new BacktesterAdapter(
-            new PaperAdapter(it, store, this.descriptor.simulation),
-            streamer
-          )
+      this.descriptor.adapter.map(it =>
+        createBacktesterAdapterFactory(
+          createPaperAdapterFactory(it, this.descriptor.simulation),
+          streamer
+        )
       ),
+      streamer.getTimeProvider(),
       store,
       cache
     );
@@ -102,13 +103,14 @@ export class Bootstrap {
     }
 
     const store = new Store();
-    const storage = this.descriptor.storage ?? new InMemoryStorageFactory();
-    const cache = new Cache(storage.create('cache'));
+    const storage = this.descriptor.storage ?? inMemoryStorageFactory();
+    const cache = new Cache(storage('cache'));
 
     const aggregate = new AdapterAggregate(
-      this.descriptor.adapter.map(
-        it => new PaperAdapter(it, store, this.descriptor.simulation)
+      this.descriptor.adapter.map(it =>
+        createPaperAdapterFactory(it, this.descriptor.simulation)
       ),
+      DefaultTimeProvider,
       store,
       cache
     );
@@ -122,10 +124,15 @@ export class Bootstrap {
    */
   live(): Session {
     const store = new Store();
-    const storage = this.descriptor.storage ?? new InMemoryStorageFactory();
-    const cache = new Cache(storage.create('cache'));
+    const storage = this.descriptor.storage ?? inMemoryStorageFactory();
+    const cache = new Cache(storage('cache'));
 
-    const aggregate = new AdapterAggregate(this.descriptor.adapter, store, cache);
+    const aggregate = new AdapterAggregate(
+      this.descriptor.adapter,
+      DefaultTimeProvider,
+      store,
+      cache
+    );
 
     return new Session(store, aggregate, this.descriptor);
   }

package/src/cli/pull.ts

@@ -40,28 +40,33 @@ 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);
 
-  await session.aggregate.feed({
-    instrument: instrumentOf(instrument),
+  await session.aggregate.feed(
+    instrumentOf(instrument),
     from,
     to,
-    destination: feed,
-    callback: timestamp => {
+    async (timestamp, events) => {
       const duration = to - from;
       const completed = timestamp - from;
 
+      await feed.save(events);
+
       bar.update(Math.floor((completed / duration) * 100));
     }
-  });
+  );
 
   bar.update(100);
   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 { d } from '../shared';
 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.tickSize).toEqual(d(0.0001));
+    expect(sut.floor(d(1.1234567))).toEqual(d(1.1234));
+    expect(sut.ceil(d(1.1234567))).toEqual(d(1.1235));
+    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 { d, decimal } 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);
 }
 
 /**
@@ -49,32 +51,29 @@ export function assetOf(asset: string): AssetSelector {
  * For example, you can combine two trading assets to create a trading instrument.
  */
 export class Asset extends AssetSelector {
-  readonly tickSize: number;
+  readonly tickSize: decimal;
 
-  constructor(name: string, adapter: string, public readonly scale: number) {
-    super(name, adapter);
+  constructor(name: string, adapterName: string, public readonly scale: number) {
+    super(name, adapterName);
 
-    this.tickSize = 1.0 / Math.pow(10, this.scale);
-  }
+    if (scale && (scale < 0 || Number.isNaN(scale))) {
+      throw invalidArgumentError(scale);
+    }
 
-  /**
-   * Trims a number to the asset precision.
-   */
-  fixed(number: number): number {
-    return fixed(number, this.scale);
+    this.tickSize = d(1.0).div(Math.pow(10, this.scale));
   }
 
   /**
    * Rounds down a number to the asset precision.
    */
-  floor(number: number): number {
-    return floor(number, this.scale);
+  floor(number: decimal): decimal {
+    return number.toFloor(this.scale);
   }
 
   /**
    * Rounds up a number to the asset precision.
    */
-  ceil(number: number): number {
-    return ceil(number, this.scale);
+  ceil(number: decimal): decimal {
+    return number.toCeil(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,113 @@
+import { d } from '../shared';
 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');
-    expect(sut.free).toEqual(0);
-    expect(sut.locked).toEqual(0);
+  test('should construct empty balance', () => {
+    const sut = new Balance(asset);
+
+    expect(sut.asset.id).toEqual('xyz:abc');
+    expect(sut.free).toEqual(d.Zero);
+    expect(sut.locked).toEqual(d.Zero);
     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);
+    sut.set(d(100), d(50));
 
-    expect(sut.asset.toString()).toEqual('xyz:abc');
-    expect(sut.free).toEqual(100);
-    expect(sut.locked).toEqual(50);
+    expect(sut.asset.id).toEqual('xyz:abc');
+    expect(sut.free).toEqual(d(100));
+    expect(sut.locked).toEqual(d(50));
+    expect(sut.total).toEqual(d(150));
     expect(Object.keys(sut.position).length).toEqual(0);
   });
+
+  test('should account positive amount', () => {
+    const sut = new Balance(asset);
+
+    sut.set(d(100), d.Zero);
+    sut.account(d(10));
+
+    expect(sut.free).toEqual(d(110));
+    expect(sut.locked).toEqual(d.Zero);
+    expect(sut.total).toEqual(d(110));
+  });
+
+  test('should account negative amount', () => {
+    const sut = new Balance(asset);
+
+    sut.set(d(100), d.Zero);
+    sut.account(d(-10));
+
+    expect(sut.free).toEqual(d(90));
+    expect(sut.locked).toEqual(d.Zero);
+    expect(sut.total).toEqual(d(90));
+  });
+
+  test('should throw for insufficient balance account amount', () => {
+    const sut = new Balance(asset);
+
+    sut.set(d(100), d.Zero);
+    const fn = () => sut.account(d(-120));
+
+    expect(fn).toThrowError();
+  });
+
+  test('should lock specific amount of available balance', () => {
+    const sut = new Balance(asset);
+
+    sut.set(d(100), d.Zero);
+    sut.lock('key', d(10));
+
+    expect(sut.free).toEqual(d(90));
+    expect(sut.locked).toEqual(d(10));
+    expect(sut.total).toEqual(d(100));
+  });
+
+  test('should throw for lock insufficient amount of available balance', () => {
+    const sut = new Balance(asset);
+
+    sut.set(d(30), d(50));
+    const fn = () => sut.lock('key', d(100));
+
+    expect(fn).toThrowError();
+  });
+
+  test('should lock an unlock specific amount of available balance', () => {
+    const sut = new Balance(asset);
+
+    sut.set(d(100), d.Zero);
+    sut.lock('key', d(40));
+    sut.tryUnlock('key');
+
+    expect(sut.free).toEqual(d(100));
+    expect(sut.locked).toEqual(d.Zero);
+    expect(sut.total).toEqual(d(100));
+  });
+
+  test('should return correct estimated unrealized pnl', () => {
+    const position = new Position('1', instrument, 'CROSS', d(2511.81), d(10.31), 20);
+
+    position.calculateEstimatedUnrealizedPnL(d(2576.44));
+
+    const sut = new Balance(asset);
+
+    sut.set(d(100), d.Zero);
+    sut.position['1'] = position;
+
+    expect(sut.getEstimatedUnrealizedPnL()).toEqual(d(0.2652));
+    expect(sut.free).toEqual(d(100).add(d(0.2652)));
+    expect(sut.total).toEqual(d(100).add(d(0.2652)));
+  });
 });