@quantform/core 0.5.15 → 0.6.4

package/src/shared/collections.spec.ts

@@ -0,0 +1,34 @@
+import { Liquidity, LiquidityAskComparer } from '../domain';
+import { d, PriorityList } from '.';
+
+describe('PriorityList', () => {
+  test('should patch a best bid and ask', () => {
+    const input = [
+      { rate: d(2), quantity: d(2) },
+      { rate: d(2), quantity: d(3) },
+      { rate: d(5), quantity: d(1) },
+      { rate: d(5), quantity: d(2) },
+      { rate: d(3), quantity: d(1) },
+      { rate: d(1), quantity: d(8) },
+      { rate: d(1), quantity: d(0) },
+      { rate: d(3), quantity: d(0) },
+      { rate: d(5), quantity: d(0) }
+    ];
+
+    const sut = new PriorityList<Liquidity>(LiquidityAskComparer, it =>
+      it.rate.toString()
+    );
+
+    input.forEach(it => (it.quantity.greaterThan(0) ? sut.enqueue(it) : sut.dequeue(it)));
+
+    const volume = sut.reduce((it, agg) => agg.add(it.quantity.mul(it.rate)), d.Zero);
+
+    const head = sut.head ?? fail();
+
+    expect(head.rate).toEqual(d(2));
+    expect(head.quantity).toEqual(d(3));
+    expect(volume).toEqual(d(6));
+    expect(sut.getByKey(d(2).toString()).quantity).toEqual(d(3));
+    expect(sut.getByKey(d(3).toString())).toEqual(undefined);
+  });
+});

package/src/shared/collections.ts

@@ -16,20 +16,139 @@ export class Set<T extends { id: string }> {
   }
 
   upsert(value: T) {
-    this.array.forEach((it, idx) => {
-      if (it.id == value.id) {
-        this.array[idx] = value;
+    const index = this.array.findIndex(it => it.id == value.id);
 
-        return value;
-      }
-    });
+    if (index >= 0) {
+      this.array[index] = value;
+
+      return value;
+    }
 
     this.array.push(value);
 
     return value;
   }
 
+  remove(value: T) {
+    const index = this.array.indexOf(value);
+    if (index > -1) {
+      this.array.splice(index, 1);
+    }
+  }
+
   asReadonlyArray(): ReadonlyArray<T> {
     return this.array;
   }
+
+  clear() {
+    this.array.splice(0, this.array.length);
+  }
+}
+
+export class PriorityList<T extends { next: T | undefined }> {
+  private valueByKey: Record<string, T> = {};
+
+  head: T | undefined;
+
+  constructor(
+    private readonly comparer: (lhs: Omit<T, 'next'>, rhs: Omit<T, 'next'>) => number,
+    private readonly getKeyFn: (key: Omit<T, 'next'>) => string
+  ) {}
+
+  getByKey(key: string): T {
+    return this.valueByKey[key];
+  }
+
+  private make(value: Omit<T, 'next'>, next: T | undefined = undefined): T {
+    const node = { ...value, next } as T;
+
+    this.valueByKey[this.getKeyFn(node)] = node;
+
+    return node;
+  }
+
+  enqueue(value: Omit<T, 'next'>) {
+    if (!this.head) {
+      this.head = this.make(value);
+    }
+
+    if (this.comparer(this.head, value) > 0) {
+      this.head = this.make(value, this.head);
+    } else if (this.comparer(this.head, value) == 0) {
+      this.head = this.make(value, this.head.next);
+    } else {
+      this.visit(it => {
+        if (it.next) {
+          if (this.comparer(it.next, value) == 0) {
+            it.next = this.make(value, it.next.next);
+
+            return false;
+          }
+
+          if (this.comparer(it.next, value) > 0) {
+            it.next = this.make(value, it.next);
+
+            return false;
+          }
+
+          return true;
+        } else {
+          it.next = this.make(value);
+
+          return false;
+        }
+      });
+    }
+  }
+
+  dequeue(value: Omit<T, 'next'>) {
+    if (!this.head) {
+      return;
+    }
+
+    if (this.comparer(this.head, value) == 0) {
+      this.head = this.head.next;
+
+      delete this.valueByKey[this.getKeyFn(value)];
+    }
+
+    this.visit(it => {
+      if (it.next && this.comparer(it.next, value) == 0) {
+        it.next = it.next.next;
+
+        delete this.valueByKey[this.getKeyFn(value)];
+
+        return true;
+      }
+
+      return false;
+    });
+  }
+
+  clear() {
+    this.head = undefined;
+    this.valueByKey = {};
+  }
+
+  visit(fn: (value: T) => boolean) {
+    let top = this.head;
+
+    while (top) {
+      if (!fn(top)) {
+        break;
+      }
+
+      top = top.next;
+    }
+  }
+
+  reduce<K>(fn: (value: T, aggregate: K) => K, initValue: K) {
+    this.visit(it => {
+      initValue = fn(it, initValue);
+
+      return true;
+    });
+
+    return initValue;
+  }
 }

package/src/shared/decimals.spec.ts

@@ -1,35 +1,29 @@
-import { ceil, fixed, floor, precision } from './decimals';
+import { d } from './decimals';
 
 describe('decimals', () => {
   test('get precision tests', () => {
-    expect(precision(0.01)).toEqual(2);
-    expect(precision(0.0054)).toEqual(4);
-    expect(precision(0.9)).toEqual(1);
-    expect(precision(0.0)).toEqual(0);
-    expect(precision(2)).toEqual(0);
-  });
-
-  test('fixed tests', () => {
-    expect(fixed(0.01, 2)).toEqual(0.01);
-    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);
+    expect(d(0.01).decimalPlaces()).toEqual(2);
+    expect(d(0.0054).decimalPlaces()).toEqual(4);
+    expect(d(0.9).decimalPlaces()).toEqual(1);
+    expect(d(0.0).decimalPlaces()).toEqual(0);
+    expect(d(2).decimalPlaces()).toEqual(0);
   });
 
   test('floor tests', () => {
-    expect(floor(0.01, 2)).toEqual(0.01);
-    expect(floor(0.000000019, 8)).toEqual(0.00000001);
-    expect(floor(0.011, 2)).toEqual(0.01);
-    expect(floor(0.019, 2)).toEqual(0.01);
-    expect(floor(0.019, 0)).toEqual(0);
+    expect(d(0.01).toFloor(2)).toEqual(d(0.01));
+    expect(d(0.000000019).toFloor(8)).toEqual(d(0.00000001));
+    expect(d(0.011).toFloor(2)).toEqual(d(0.01));
+    expect(d(0.019).toFloor(2)).toEqual(d(0.01));
+    expect(d(0.019).toFloor(0)).toEqual(d.Zero);
+    expect(d(0.01).toFloor(2)).toEqual(d(0.01));
+    expect(d(0.00000058).toFloor(8)).toEqual(d(0.00000058));
   });
 
   test('ceil tests', () => {
-    expect(ceil(0.01, 2)).toEqual(0.01);
-    expect(ceil(0.000000019, 8)).toEqual(0.00000002);
-    expect(ceil(0.011, 2)).toEqual(0.02);
-    expect(ceil(0.019, 2)).toEqual(0.02);
-    expect(ceil(0.019, 0)).toEqual(1);
+    expect(d(0.01).toCeil(2)).toEqual(d(0.01));
+    expect(d(0.000000019).toCeil(8)).toEqual(d(0.00000002));
+    expect(d(0.011).toCeil(2)).toEqual(d(0.02));
+    expect(d(0.019).toCeil(2)).toEqual(d(0.02));
+    expect(d(0.019).toCeil(0)).toEqual(d(1));
   });
 });

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 (
-    Math.floor((number + Number.EPSILON) * Math.pow(10, precision)) /
-    Math.pow(10, 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, amount: number) {
-  return (exitRate / entryRate - 1) * amount;
+export function pnl(entryRate: decimal, exitRate: decimal, amount: decimal) {
+  return exitRate.div(entryRate).minus(1).mul(amount);
 }
 
 /**

package/src/shared/environment.ts

@@ -0,0 +1,13 @@
+export function workingDirectory() {
+  return './.quantform/';
+}
+
+export function getEnvVar(name: string, optional = false): string {
+  const value = process.env[name];
+
+  if (!value && !optional) {
+    throw new Error(`Missing environment variable: ${name}`);
+  }
+
+  return value ?? '';
+}

package/src/shared/index.ts

@@ -1,6 +1,7 @@
 export * from './datetime';
 export * from './decimals';
-export * from './io';
+export * from './environment';
 export * from './logger';
 export * from './policy';
 export * from './collections';
+export * from './pipe';

package/src/shared/logger.ts

@@ -1,9 +1,37 @@
+import chalk from 'chalk';
+
+import { now } from './datetime';
+
+const colorize = (content: string) => {
+  let hash = 0x811c9dc5;
+
+  for (let i = 0; i < content.length; i++) {
+    hash ^= content.charCodeAt(i);
+    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  }
+
+  return chalk.hex('#' + (hash * 0xfffff * 1000000).toString(16).slice(0, 6))(content);
+};
+
+const time = () => chalk.gray(new Date(now()).toISOString());
+
 export class Logger {
-  public static info = console && console.info && console.info.bind(console);
-  public static log = console && console.log && console.log.bind(console);
-  public static debug = console && console.debug && console.debug.bind(console);
-  public static warn = console && console.warn && console.warn.bind(console);
-  public static error = console && console.error && console.error.bind(console);
-  public static assert = console && console.assert && console.assert.bind(console);
-  public static trace = console && console.trace && console.trace.bind(console);
+  public static info = (context: string, message: string) =>
+    console.info(`${time()} ${colorize(context)}: ${message}`);
+
+  public static debug = (context: string, message: string) =>
+    console.debug(`${time()} ${colorize(context)}: ${message}`);
+
+  public static warn = (context: string, message: string) =>
+    console.warn(`${time()} ${colorize(context)}: ${message}`);
+
+  public static error = (context: string, error: unknown) => {
+    let message = 'Unknown Error';
+
+    if (error instanceof Error) {
+      message = error.message;
+    }
+
+    console.error(`${time()} ${colorize(context)}: ${message}`);
+  };
 }

package/src/shared/pipe.ts

@@ -0,0 +1,12 @@
+import { filter, map, Observable } from 'rxjs';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-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/storage/cache.ts

@@ -16,7 +16,9 @@ export class Cache {
       to: time + 1
     });
 
-    if ((!payload.length || payload[0].timestamp < time - options.ttl) ?? 60 * 60 * 24) {
+    const ttl = options.ttl ?? 60 * 60 * 24;
+
+    if (!payload.length || payload[0].timestamp < time - ttl) {
       const value = await getter();
 
       await this.storage.save(options.key, [

package/src/storage/feed.ts

@@ -1,6 +1,9 @@
-import { Candle, InstrumentSelector } from '../domain';
-import { StoreEvent } from '../store';
-import { Storage, StorageQueryOptions } from './storage';
+import { InstrumentSelector } from '../domain';
+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,25 +21,29 @@ export class Feed {
 
   /**
    *
-   * @param instrument
-   * @param candles
+   * @param events
    * @returns
    */
-  save(instrument: InstrumentSelector, candles: Candle[]): Promise<void> {
-    return this.storage.save(
-      instrument.toString(),
-      candles.map(it => ({
-        timestamp: it.timestamp,
-        kind: 'candle',
-        json: JSON.stringify({
-          o: it.open,
-          h: it.high,
-          l: it.low,
-          c: it.close,
-          v: it.volume
-        })
-      }))
-    );
+  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]);
+    }
   }
 
   /**
@@ -48,20 +55,70 @@ export class Feed {
   async query(
     instrument: InstrumentSelector,
     options: StorageQueryOptions
-  ): Promise<Candle[]> {
-    const rows = await this.storage.query(instrument.id, options);
-
-    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
+  ): 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
+      );
+    }
+
+    throw new Error(`Unsupported event: ${document.kind}`);
   }
 }

package/src/storage/storage.ts

@@ -73,23 +73,25 @@ export class InMemoryStorage implements Storage {
 
     let query = this.tables[library];
 
-    if (options.from) {
-      query = query.filter(it => it.timestamp > options.from);
+    const { from, to, kind, count } = options;
+
+    if (from) {
+      query = query.filter(it => it.timestamp > from);
     }
 
-    if (options.to) {
-      query = query.filter(it => it.timestamp < options.to);
+    if (to) {
+      query = query.filter(it => it.timestamp < to);
     }
 
-    if (options.kind) {
-      query = query.filter(it => it.kind == options.kind);
+    if (kind) {
+      query = query.filter(it => it.kind == kind);
     }
 
-    if (options.from == undefined && options.to) {
+    if (from == undefined && to) {
       query = query.reverse();
     }
 
-    if (options.count) {
+    if (count) {
       query = query.slice(0, options.count);
     }
 

package/src/store/error.ts

@@ -0,0 +1,36 @@
+import { AssetSelector, InstrumentSelector, OrderState } from '../domain';
+
+export function assetNotSupportedError(selector: AssetSelector) {
+  return new Error(`asset ${selector.id} not supported.`);
+}
+
+export function instrumentNotSubscribedError(selector: InstrumentSelector) {
+  return new Error(`trying to patch a not subscribed instrument ${selector.id}`);
+}
+
+export function instrumentNotSupportedError(selector: InstrumentSelector) {
+  return new Error(`instrument ${selector.id} not supported.`);
+}
+
+export function liquidationError() {
+  return new Error('you have been liquidated.');
+}
+
+export function orderNotFoundError(id: string) {
+  return new Error(`trying to patch unknown order: ${id}`);
+}
+
+export function balanceNotFoundError(selector: AssetSelector) {
+  return new Error(`balance not found: ${selector.id}`);
+}
+
+export function orderInvalidStateError(
+  currentState: OrderState,
+  requiredStates: OrderState[]
+) {
+  return new Error(
+    `order state ${currentState} is not in one of required states: ${requiredStates.join(
+      ', '
+    )}`
+  );
+}

package/src/store/index.ts

@@ -1,9 +1,9 @@
 export * from './store';
 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';
+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';