@quantform/core 0.5.13 → 0.5.23

package/src/shared/decimals.ts

@@ -1,79 +1,46 @@
-/**
- * calculate the number of decimal places of a number
- * @param value
- * @returns a precision number of the value
- */
-export function precision(value: number) {
-  if (!isFinite(value)) {
-    return 0;
-  }
-
-  let e = 1;
-  let p = 0;
+import { Decimal } from 'decimal.js';
 
-  while (Math.round(value * e) / e !== value) {
-    e *= 10;
-    p++;
+declare module 'decimal.js' {
+  interface Decimal {
+    toFloor(decimalPlaces: number): Decimal;
+    toCeil(decimalPlaces: number): Decimal;
   }
-
-  return p;
 }
 
-/**
- * round down the number to the given precision
- * @param number
- * @param precision
- * @returns rounded down number
- */
-export function floor(number: number, precision: number): number {
-  const fixed = Math.pow(10, precision);
+Decimal.prototype.toFloor = function (decimalPlaces: number) {
+  return this.toDecimalPlaces(decimalPlaces, Decimal.ROUND_FLOOR);
+};
 
-  return Math.floor(number * fixed) / fixed;
-}
+Decimal.prototype.toCeil = function (decimalPlaces: number) {
+  return this.toDecimalPlaces(decimalPlaces, Decimal.ROUND_CEIL);
+};
 
-/**
- * round up the number to the given precision
- * @param number
- * @param precision
- * @returns rounded up number
- */
-export function ceil(number: number, precision: number): number {
-  const fixed = Math.pow(10, precision);
+export class decimal extends Decimal {}
 
-  return Math.ceil(number * fixed) / fixed;
+export function d(value: Decimal.Value) {
+  return new decimal(value);
 }
 
-/**
- * round the number to the given precision
- * @param number
- * @param precision
- * @returns rounded number
- */
-export function fixed(number: number, precision: number): number {
-  return floor(number, precision);
-}
+d.Zero = new decimal(0);
 
-export function weightedMean(values: number[], weights: number[]) {
+export function weightedMean(values: decimal[], weights: decimal[]): decimal {
   const result = values
     .map((value, i) => {
       const weight = weights[i];
-      const sum = value * weight;
+      const sum = value.mul(weight);
       return [sum, weight];
     })
-    .reduce((p, c) => [p[0] + c[0], p[1] + c[1]], [0, 0]);
+    .reduce((p, c) => [p[0].add(c[0]), p[1].add(c[1])], [d.Zero, d.Zero]);
 
   if (!result[1]) {
-    return 0;
+    return d.Zero;
   }
 
-  return result[0] / result[1];
+  return result[0].div(result[1]);
 }
 
-export function pnl(entryRate: number, exitRate: number, size: number) {
-  const cost = size * entryRate;
-  const unrealized = size * exitRate;
-
-  return unrealized - cost;
+export function pnl(entryRate: decimal, exitRate: decimal, amount: decimal) {
+  return exitRate.div(entryRate).minus(1).mul(amount);
 }
 
 /**

package/src/shared/index.ts

@@ -3,4 +3,5 @@ export * from './decimals';
 export * from './io';
 export * from './logger';
 export * from './policy';
-export * from './topic';
+export * from './collections';
+export * from './pipe';

package/src/shared/io.ts

@@ -1,5 +1,3 @@
-import fs = require('fs');
-
 export function workingDirectory() {
   return './.quantform/';
 }

package/src/shared/pipe.ts

@@ -0,0 +1,12 @@
+import { filter, map, Observable } from 'rxjs';
+
+// tslint:disable-next-line: no-any
+type Constructor<T> = new (...args: any[]) => T;
+
+export function ofType<T extends K, K>(type: Constructor<T>) {
+  return (input: Observable<K>) =>
+    input.pipe(
+      filter(it => it instanceof type),
+      map(it => it as T)
+    );
+}

package/src/shared/policy.ts

@@ -1,18 +1,5 @@
-import * as hash from 'object-hash';
 import { retryAsync } from 'ts-retry';
 
 export function retry<T>(fn: () => Promise<T>): Promise<T> {
   return retryAsync(fn, { delay: 1000, maxTry: 3 });
 }
-
-const inMemoryCache: Record<string, any> = {};
-
-export async function cache<T>(key: any, fn: () => Promise<T>): Promise<T> {
-  const hashed = hash(key);
-
-  if (inMemoryCache[hashed]) {
-    return inMemoryCache[hashed];
-  }
-
-  return (inMemoryCache[hashed] = await fn());
-}

package/src/storage/cache.spec.ts

@@ -0,0 +1,18 @@
+import { Cache } from './cache';
+import { InMemoryStorage } from './storage';
+
+describe('Cache', () => {
+  test('should return cached value', async () => {
+    const cache = new Cache(new InMemoryStorage());
+
+    const value1 = await cache.tryGet(() => Promise.resolve('quantform-1'), {
+      key: 'test'
+    });
+    const value2 = await cache.tryGet(() => Promise.resolve('quantform-2'), {
+      key: 'test'
+    });
+
+    expect(value1).toEqual('quantform-1');
+    expect(value2).toEqual('quantform-1');
+  });
+});

package/src/storage/cache.ts

@@ -13,7 +13,7 @@ export class Cache {
     const payload = await this.storage.query(options.key, {
       kind: 'cache',
       count: 1,
-      to: time
+      to: time + 1
     });
 
     if ((!payload.length || payload[0].timestamp < time - options.ttl) ?? 60 * 60 * 24) {

package/src/storage/feed.ts

@@ -1,6 +1,9 @@
 import { InstrumentSelector } from '../domain';
-import { StoreEvent } from '../store';
-import { Storage, StorageQueryOptions } from './storage';
+import { d } from '../shared';
+import { OrderbookPatchEvent, TradePatchEvent } from '../store';
+import { Storage, StorageDocument, StorageQueryOptions } from './storage';
+
+export type StorageEvent = TradePatchEvent | OrderbookPatchEvent;
 
 /**
  * Represents a storage supposed to store historical data.
@@ -18,21 +21,29 @@ export class Feed {
 
   /**
    *
-   * @param instrument
    * @param events
    * @returns
    */
-  save(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void> {
-    return this.storage.save(
-      instrument.toString(),
-      events.map(it => ({
-        timestamp: it.timestamp,
-        kind: it.type,
-        json: JSON.stringify(it, (key, value) =>
-          key != 'timestamp' && key != 'type' && key != 'instrument' ? value : undefined
-        )
-      }))
-    );
+  async save(events: StorageEvent[]): Promise<void> {
+    const grouped = events.reduce((aggregate, it) => {
+      const document = this.serializeEvent(it);
+
+      if (!document) {
+        return aggregate;
+      }
+
+      if (aggregate[it.instrument.id]) {
+        aggregate[it.instrument.id].push(document);
+      } else {
+        aggregate[it.instrument.id] = [document];
+      }
+
+      return aggregate;
+    }, {} as Record<string, StorageDocument[]>);
+
+    for (const instrument in grouped) {
+      await this.storage.save(instrument, grouped[instrument]);
+    }
   }
 
   /**
@@ -44,14 +55,68 @@ export class Feed {
   async query(
     instrument: InstrumentSelector,
     options: StorageQueryOptions
-  ): Promise<StoreEvent[]> {
-    const rows = await this.storage.query(instrument.toString(), options);
-
-    return rows.map(it => ({
-      timestamp: it.timestamp,
-      type: it.kind,
-      instrument,
-      ...JSON.parse(it.json)
-    }));
+  ): Promise<StorageEvent[]> {
+    const documents = await this.storage.query(instrument.id, options);
+
+    return documents.map(it => this.deserializeEvent(it, instrument));
+  }
+
+  /**
+   * Converts a StorageEvent to a persisted StorageDocument.
+   */
+  protected serializeEvent(event: StorageEvent): StorageDocument | undefined {
+    if (event instanceof OrderbookPatchEvent) {
+      return {
+        timestamp: event.timestamp,
+        kind: 'orderbook',
+        json: JSON.stringify({
+          ar: event.ask.rate.toString(),
+          ab: event.ask.quantity.toString(),
+          br: event.bid.rate.toString(),
+          bb: event.bid.quantity.toString()
+        })
+      };
+    }
+
+    if (event instanceof TradePatchEvent) {
+      return {
+        timestamp: event.timestamp,
+        kind: 'trade',
+        json: JSON.stringify({
+          r: event.rate.toString(),
+          q: event.quantity.toString()
+        })
+      };
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Converts a persisted StorageDocument to a StorageEvent.
+   */
+  protected deserializeEvent(
+    document: StorageDocument,
+    instrument: InstrumentSelector
+  ): StorageEvent {
+    const payload = JSON.parse(document.json);
+
+    if (document.kind === 'trade') {
+      return new TradePatchEvent(
+        instrument,
+        d(payload.r),
+        d(payload.q),
+        document.timestamp
+      );
+    }
+
+    if (document.kind === 'orderbook') {
+      return new OrderbookPatchEvent(
+        instrument,
+        { rate: d(payload.ar), quantity: d(payload.aq), next: undefined },
+        { rate: d(payload.bb), quantity: d(payload.bq), next: undefined },
+        document.timestamp
+      );
+    }
   }
 }

package/src/storage/storage.ts

@@ -11,6 +11,11 @@ export type StorageQueryOptions = {
   count: number;
 };
 
+/**
+ *
+ */
+export type StorageFactory = (type: string) => Storage;
+
 /**
  *
  */
@@ -35,11 +40,10 @@ export interface Storage {
   query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]>;
 }
 
-/**
- *
- */
-export interface StorageFactory {
-  create(type: string): Storage;
+export function inMemoryStorageFactory(): StorageFactory {
+  const storage: Record<string, Storage> = {};
+
+  return (type: string) => storage[type] ?? (storage[type] = new InMemoryStorage());
 }
 
 /**
@@ -118,11 +122,3 @@ export class InMemoryStorage implements Storage {
     this.tables = {};
   }
 }
-
-export class InMemoryStorageFactory implements StorageFactory {
-  private readonly storage: Record<string, Storage> = {};
-
-  create(type: string): Storage {
-    return this.storage[type] ?? (this.storage[type] = new InMemoryStorage());
-  }
-}

package/src/store/index.ts

@@ -1,3 +1,9 @@
-export * from './event';
 export * from './store';
-export * from './store.state';
+export * from './store-state';
+export * from './store-balance.event';
+export * from './store-instrument.event';
+export * from './store-order.event';
+export * from './store-orderbook.event';
+export * from './store-position.event';
+export * from './store-trade.event';
+export * from './store.event';

package/src/store/{event/store-balance.event.spec.ts → store-balance.event.spec.ts}

@@ -1,10 +1,10 @@
-import { Asset, Commission } from '../../domain';
-import { now } from '../../shared';
-import { Store } from '..';
-import { BalancePatchEvent } from '.';
+import { Asset, Commission } from '../domain';
+import { d, now } from '../shared';
+import { Store } from '.';
+import { BalancePatchEvent } from './store-balance.event';
 import { InstrumentPatchEvent } from './store-instrument.event';
 
-describe('balance event tests', () => {
+describe('BalancePatchEvent', () => {
   test('should patch a store', () => {
     const base = new Asset('de30', 'cex', 2);
     const quote = new Asset('usd', 'cex', 2);
@@ -15,15 +15,15 @@ describe('balance event tests', () => {
     store.changes$.subscribe(it => (component = it));
 
     store.dispatch(
-      new InstrumentPatchEvent(timestamp, base, quote, new Commission(0, 0), '')
+      new InstrumentPatchEvent(timestamp, base, quote, new Commission(d.Zero, d.Zero), '')
     );
-    store.dispatch(new BalancePatchEvent(base, 100, 0, timestamp));
+    store.dispatch(new BalancePatchEvent(base, d(100), d.Zero, timestamp));
 
-    const balance = store.snapshot.balance[base.toString()];
+    const balance = store.snapshot.balance.get(base.id);
 
     expect(balance).toEqual(component);
-    expect(balance.free).toEqual(100);
-    expect(balance.locked).toEqual(0);
+    expect(balance.free).toEqual(d(100));
+    expect(balance.locked).toEqual(d.Zero);
     expect(balance.timestamp).toEqual(timestamp);
     expect(store.snapshot.timestamp).toEqual(timestamp);
   });

package/src/store/store-balance.event.ts

@@ -0,0 +1,124 @@
+import { AssetSelector, Balance, InstrumentSelector } from '../domain';
+import { decimal, timestamp } from '../shared';
+import { StoreEvent } from './store.event';
+import { State, StateChangeTracker } from './store-state';
+
+/**
+ * Updates the free and freezed balance of the given asset.
+ */
+export class BalancePatchEvent implements StoreEvent {
+  constructor(
+    readonly asset: AssetSelector,
+    readonly free: decimal,
+    readonly freezed: decimal,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker) {
+    // you can have not tradeable assets in wallet, skip them.
+    const asset = state.universe.asset.get(this.asset.id);
+    if (!asset) {
+      return;
+    }
+
+    const balance = state.balance.tryGetOrSet(this.asset.id, () => new Balance(asset));
+
+    balance.timestamp = this.timestamp;
+    balance.set(this.free, this.freezed);
+
+    state.timestamp = this.timestamp;
+
+    changes.commit(balance);
+  }
+}
+/**
+ *
+ */
+export class BalanceTransactEvent implements StoreEvent {
+  constructor(
+    readonly asset: AssetSelector,
+    readonly amount: decimal,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker) {
+    const balance = state.balance.tryGetOrSet(this.asset.id, () => {
+      const asset = state.universe.asset.get(this.asset.id);
+
+      return new Balance(asset);
+    });
+
+    balance.timestamp = this.timestamp;
+    balance.account(this.amount);
+
+    state.timestamp = this.timestamp;
+
+    changes.commit(balance);
+  }
+}
+
+/**
+ *
+ */
+export class BalanceLockOrderEvent implements StoreEvent {
+  constructor(
+    readonly orderId: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker) {
+    const order = state.order.get(this.instrument.id).get(this.orderId);
+    const base = state.balance.get(order.instrument.base.id);
+    const quote = state.balance.get(order.instrument.quote.id);
+
+    const balanceToLock = order.calculateBalanceToLock(base, quote);
+
+    state.timestamp = this.timestamp;
+
+    if (balanceToLock.base.greaterThan(0)) {
+      base.timestamp = this.timestamp;
+      base.lock(this.orderId, balanceToLock.base);
+
+      changes.commit(base);
+    }
+
+    if (balanceToLock.quote.greaterThan(0)) {
+      quote.timestamp = this.timestamp;
+      quote.lock(this.orderId, balanceToLock.quote);
+
+      changes.commit(quote);
+    }
+  }
+}
+
+/**
+ *
+ */
+export class BalanceUnlockOrderEvent implements StoreEvent {
+  constructor(
+    readonly orderId: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker) {
+    const order = state.order.get(this.instrument.id).get(this.orderId);
+    const base = state.balance.get(order.instrument.base.id);
+    const quote = state.balance.get(order.instrument.quote.id);
+
+    state.timestamp = this.timestamp;
+
+    if (base.tryUnlock(this.orderId)) {
+      base.timestamp = this.timestamp;
+
+      changes.commit(base);
+    }
+
+    if (quote.tryUnlock(this.orderId)) {
+      quote.timestamp = this.timestamp;
+
+      changes.commit(quote);
+    }
+  }
+}

package/src/store/store-instrument.event.spec.ts

@@ -0,0 +1,25 @@
+import { Store } from '..';
+import { Asset, Commission } from '../domain';
+import { d, now } from '../shared';
+import { InstrumentPatchEvent } from './store-instrument.event';
+
+describe('InstrumentPatchEvent', () => {
+  test('should patch a store', () => {
+    const timestamp = now();
+    const store = new Store();
+    const base = new Asset('de30', 'cex', 2);
+    const quote = new Asset('usd', 'cex', 2);
+
+    store.dispatch(
+      new InstrumentPatchEvent(timestamp, base, quote, new Commission(d.Zero, d.Zero), '')
+    );
+
+    const { universe } = store.snapshot;
+
+    expect(universe.instrument.get('cex:de30-usd').base).toEqual(base);
+    expect(universe.instrument.get('cex:de30-usd').quote).toEqual(quote);
+    expect(universe.instrument.get('cex:de30-usd').timestamp).toEqual(timestamp);
+    expect(universe.instrument.asReadonlyArray().length).toEqual(1);
+    expect(universe.asset.asReadonlyArray().length).toEqual(2);
+  });
+});

package/src/store/store-instrument.event.ts

@@ -0,0 +1,72 @@
+import { Asset, Commission, Instrument, InstrumentSelector } from '../domain';
+import { timestamp } from '../shared';
+import { State, StateChangeTracker } from '../store';
+import { StoreEvent } from './store.event';
+import { InnerSet } from './store-state';
+
+export class InstrumentPatchEvent implements StoreEvent {
+  constructor(
+    readonly timestamp: timestamp,
+    readonly base: Asset,
+    readonly quote: Asset,
+    readonly commission: Commission,
+    readonly raw: string,
+    readonly leverage?: number
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const selector = new InstrumentSelector(
+      this.base.name,
+      this.quote.name,
+      this.base.adapterName
+    );
+
+    const instrument = state.universe.instrument.tryGetOrSet(selector.id, () => {
+      state.universe.asset.tryGetOrSet(
+        this.base.id,
+        () => new Asset(this.base.name, this.base.adapterName, 8)
+      );
+
+      state.universe.asset.tryGetOrSet(
+        this.quote.id,
+        () => new Asset(this.quote.name, this.quote.adapterName, 8)
+      );
+
+      state.order.tryGetOrSet(selector.id, () => new InnerSet(selector.id));
+
+      return new Instrument(this.base, this.quote, this.raw);
+    });
+
+    instrument.timestamp = this.timestamp;
+    instrument.commission = this.commission;
+
+    if (this.leverage) {
+      instrument.leverage = this.leverage;
+    }
+
+    changes.commit(instrument);
+  }
+}
+
+export class InstrumentSubscriptionEvent implements StoreEvent {
+  constructor(
+    readonly timestamp: timestamp,
+    readonly instrument: InstrumentSelector,
+    readonly subscribed: boolean
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const instrument = state.universe.instrument.get(this.instrument.id);
+    if (!instrument) {
+      throw new Error('invalid instrument');
+    }
+
+    if (this.subscribed) {
+      state.subscription.instrument.upsert(instrument);
+      state.subscription.asset.upsert(state.universe.asset.get(instrument.base.id));
+      state.subscription.asset.upsert(state.universe.asset.get(instrument.quote.id));
+    }
+
+    changes.commit(instrument);
+  }
+}

package/src/store/store-order.event.spec.ts

@@ -0,0 +1,28 @@
+import { Asset, Instrument, Order } from '../domain';
+import { d, now } from '../shared';
+import { Store } from '../store';
+import { OrderLoadEvent } from './store-order.event';
+
+const instrument = new Instrument(
+  new Asset('btc', 'binance', 8),
+  new Asset('usdt', 'binance', 2),
+  'binance:btc-usdt'
+);
+
+describe('OrderLoadEvent', () => {
+  test('should load order to store', () => {
+    const timestamp = now();
+    const store = new Store();
+    const order = Order.market(instrument, d(1.0));
+
+    order.state = 'PENDING';
+
+    store.snapshot.universe.instrument.upsert(instrument);
+    store.snapshot.subscription.instrument.upsert(instrument);
+
+    store.dispatch(new OrderLoadEvent(order, timestamp));
+
+    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
+    expect(store.snapshot.order.get(instrument.id).get(order.id)).toEqual(order);
+  });
+});