@quantform/core 0.4.11 → 0.5.15

package/src/indicator/wma.spec.ts

@@ -1,7 +1,8 @@
 import { from } from 'rxjs';
+
 import { wma } from './wma';
 
-describe('wma tests', () => {
+describe('wma', () => {
   test('should return expected value', done => {
     let value;
     //12 Dec 2020 00:00

package/src/indicator/wma.ts

@@ -1,4 +1,5 @@
 import { filter, map, Observable, share } from 'rxjs';
+
 import { window } from './window';
 
 export function wma<T>(length: number, fn: (it: T) => number) {

package/src/shared/collections.ts

@@ -0,0 +1,35 @@
+export class Set<T extends { id: string }> {
+  private readonly array: Array<T> = [];
+
+  constructor(values?: ReadonlyArray<T>) {
+    if (values) {
+      values.forEach(it => this.upsert(it));
+    }
+  }
+
+  get(id: string) {
+    return this.array.find(it => it.id == id);
+  }
+
+  tryGetOrSet(id: string, setter: () => T): T {
+    return this.get(id) ?? this.upsert(setter());
+  }
+
+  upsert(value: T) {
+    this.array.forEach((it, idx) => {
+      if (it.id == value.id) {
+        this.array[idx] = value;
+
+        return value;
+      }
+    });
+
+    this.array.push(value);
+
+    return value;
+  }
+
+  asReadonlyArray(): ReadonlyArray<T> {
+    return this.array;
+  }
+}

package/src/shared/datetime.ts

@@ -3,15 +3,3 @@ export type timestamp = number;
 export function now(): timestamp {
   return new Date().getTime();
 }
-
-export function toString(timestamp: timestamp): string {
-  const date = new Date(timestamp);
-  const day = ('0' + date.getDate()).slice(-2);
-  const month = ('0' + (date.getMonth() + 1)).slice(-2);
-  const year = date.getFullYear();
-  const hours = ('0' + date.getHours()).slice(-2);
-  const minutes = ('0' + date.getMinutes()).slice(-2);
-  const seconds = ('0' + date.getSeconds()).slice(-2);
-
-  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
-}

package/src/shared/decimals.spec.ts

@@ -1,6 +1,6 @@
 import { ceil, fixed, floor, precision } from './decimals';
 
-describe('decimals tests', () => {
+describe('decimals', () => {
   test('get precision tests', () => {
     expect(precision(0.01)).toEqual(2);
     expect(precision(0.0054)).toEqual(4);
@@ -14,6 +14,7 @@ describe('decimals tests', () => {
     expect(fixed(0.011, 2)).toEqual(0.01);
     expect(fixed(0.019, 2)).toEqual(0.01);
     expect(fixed(0.019, 0)).toEqual(0);
+    expect(fixed(0.00000058, 8)).toEqual(0.00000058);
   });
 
   test('floor tests', () => {

package/src/shared/decimals.ts

@@ -50,7 +50,10 @@ export function ceil(number: number, precision: number): number {
  * @returns rounded number
  */
 export function fixed(number: number, precision: number): number {
-  return floor(number, precision);
+  return (
+    Math.floor((number + Number.EPSILON) * Math.pow(10, precision)) /
+    Math.pow(10, precision)
+  );
 }
 
 export function weightedMean(values: number[], weights: number[]) {
@@ -69,11 +72,8 @@ export function weightedMean(values: number[], weights: number[]) {
   return result[0] / 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: number, exitRate: number, amount: number) {
+  return (exitRate / entryRate - 1) * amount;
 }
 
 /**

package/src/shared/index.ts

@@ -3,6 +3,4 @@ export * from './decimals';
 export * from './io';
 export * from './logger';
 export * from './policy';
-export * from './task';
-export * from './topic';
-export * from './worker';
+export * from './collections';

package/src/shared/io.ts

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

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

@@ -0,0 +1,35 @@
+import { now } from '../shared';
+import { Storage } from './storage';
+
+export class Cache {
+  constructor(private readonly storage: Storage) {}
+
+  async tryGet<T>(
+    getter: () => Promise<T>,
+    options: { key: string; ttl?: number }
+  ): Promise<T> {
+    const time = now();
+
+    const payload = await this.storage.query(options.key, {
+      kind: 'cache',
+      count: 1,
+      to: time + 1
+    });
+
+    if ((!payload.length || payload[0].timestamp < time - options.ttl) ?? 60 * 60 * 24) {
+      const value = await getter();
+
+      await this.storage.save(options.key, [
+        {
+          timestamp: time,
+          kind: 'cache',
+          json: JSON.stringify(value)
+        }
+      ]);
+
+      return value;
+    }
+
+    return JSON.parse(payload[0].json);
+  }
+}

package/src/storage/feed.ts

@@ -1,4 +1,4 @@
-import { InstrumentSelector } from '../domain';
+import { Candle, InstrumentSelector } from '../domain';
 import { StoreEvent } from '../store';
 import { Storage, StorageQueryOptions } from './storage';
 
@@ -19,18 +19,22 @@ export class Feed {
   /**
    *
    * @param instrument
-   * @param events
+   * @param candles
    * @returns
    */
-  save(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void> {
+  save(instrument: InstrumentSelector, candles: Candle[]): Promise<void> {
     return this.storage.save(
       instrument.toString(),
-      events.map(it => ({
+      candles.map(it => ({
         timestamp: it.timestamp,
-        kind: it.type,
-        json: JSON.stringify(it, (key, value) =>
-          key != 'timestamp' && key != 'type' && key != 'instrument' ? value : undefined
-        )
+        kind: 'candle',
+        json: JSON.stringify({
+          o: it.open,
+          h: it.high,
+          l: it.low,
+          c: it.close,
+          v: it.volume
+        })
       }))
     );
   }
@@ -44,14 +48,20 @@ export class Feed {
   async query(
     instrument: InstrumentSelector,
     options: StorageQueryOptions
-  ): Promise<StoreEvent[]> {
-    const rows = await this.storage.query(instrument.toString(), options);
+  ): Promise<Candle[]> {
+    const rows = await this.storage.query(instrument.id, options);
 
-    return rows.map(it => ({
-      timestamp: it.timestamp,
-      type: it.kind,
-      instrument,
-      ...JSON.parse(it.json)
-    }));
+    return rows.map(it => {
+      const payload = JSON.parse(it.json);
+
+      return new Candle(
+        it.timestamp,
+        payload.o,
+        payload.h,
+        payload.l,
+        payload.c,
+        payload.v
+      );
+    });
   }
 }

package/src/storage/index.ts

@@ -1,3 +1,4 @@
 export * from './feed';
 export * from './measurement';
 export * from './storage';
+export * from './cache';

package/src/storage/storage.ts

@@ -11,6 +11,11 @@ export type StorageQueryOptions = {
   count: number;
 };
 
+/**
+ *
+ */
+export type StorageFactory = (type: string) => Storage;
+
 /**
  *
  */
@@ -35,6 +40,12 @@ export interface Storage {
   query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]>;
 }
 
+export function inMemoryStorageFactory(): StorageFactory {
+  const storage: Record<string, Storage> = {};
+
+  return (type: string) => storage[type] ?? (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 { BalancePatchEvent } from '.';
-import { Store } from '..';
-import { Asset, Commission } from '../../domain';
-import { now } from '../../shared';
+import { Asset, Commission } from '../domain';
+import { 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);
@@ -19,11 +19,11 @@ describe('balance event tests', () => {
     );
     store.dispatch(new BalancePatchEvent(base, 100, 0, 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.freezed).toEqual(0);
+    expect(balance.locked).toEqual(0);
     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 { 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: number,
+    readonly freezed: number,
+    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: number,
+    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 > 0) {
+      base.timestamp = this.timestamp;
+      base.lock(this.orderId, balanceToLock.base);
+
+      changes.commit(base);
+    }
+
+    if (balanceToLock.quote > 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 { 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(0, 0), '')
+    );
+
+    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, InstrumentSelector, Instrument } from '../domain';
+import { timestamp } from '../shared';
+import { State, StateChangeTracker } from '../store';
+import { InnerSet } from './store-state';
+import { StoreEvent } from './store.event';
+
+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 { 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, 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);
+  });
+});