@quantform/core 0.6.6 → 0.7.0-beta.4

package/src/shared/collections.spec.ts

@@ -1,34 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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) {
-    const index = this.array.findIndex(it => it.id == value.id);
-
-    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/logger.ts

@@ -1,39 +0,0 @@
-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 = (context: string, message: string) =>
-    console.info(`${this.prefix(context)}: ${message}`);
-
-  public static debug = (context: string, message: string) =>
-    console.debug(`${this.prefix(context)}: ${message}`);
-
-  public static warn = (context: string, message: string) =>
-    console.warn(`${this.prefix(context)}: ${message}`);
-
-  public static error = (context: string, error: unknown) => {
-    let message = 'Unknown Error';
-
-    if (error instanceof Error) {
-      message = error.message;
-    }
-
-    console.error(`${this.prefix(context)}: ${message}`);
-  };
-
-  public static prefix = (context: string) => `${time()} ${colorize(context)}`;
-}

package/src/shared/pipe.ts

@@ -1,12 +0,0 @@
-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/shared/policy.ts

@@ -1,5 +0,0 @@
-import { retryAsync } from 'ts-retry';
-
-export function retry<T>(fn: () => Promise<T>): Promise<T> {
-  return retryAsync(fn, { delay: 1000, maxTry: 3 });
-}

package/src/storage/cache.spec.ts

@@ -1,18 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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
-    });
-
-    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, [
-        {
-          timestamp: time,
-          kind: 'cache',
-          json: JSON.stringify(value)
-        }
-      ]);
-
-      return value;
-    }
-
-    return JSON.parse(payload[0].json);
-  }
-}

package/src/storage/feed.ts

@@ -1,124 +0,0 @@
-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.
- * You can use CLI to fetch and save data in the Feed.
- */
-export class Feed {
-  constructor(private readonly storage: Storage) {}
-
-  /**
-   * Returns all instrument names stored in the feed.
-   */
-  index(): Promise<Array<string>> {
-    return this.storage.index();
-  }
-
-  /**
-   *
-   * @param events
-   * @returns
-   */
-  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]);
-    }
-  }
-
-  /**
-   *
-   * @param instrument
-   * @param options
-   * @returns
-   */
-  async query(
-    instrument: InstrumentSelector,
-    options: StorageQueryOptions
-  ): 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/measurement.ts

@@ -1,56 +0,0 @@
-import { timestamp } from '../shared';
-import { Storage, StorageQueryOptions } from './storage';
-
-export interface Measure {
-  timestamp: timestamp;
-  kind: string;
-  payload: any;
-}
-
-/**
- *
- */
-export class Measurement {
-  constructor(private readonly storage: Storage) {}
-
-  /**
-   *
-   * @returns
-   */
-  async index(): Promise<Array<number>> {
-    return (await this.storage.index()).map(it => Number(it));
-  }
-
-  /**
-   *
-   * @param session
-   * @param measurements
-   * @returns
-   */
-  save(session: number, measurements: Measure[]): Promise<void> {
-    return this.storage.save(
-      session.toString(),
-      measurements.map(it => ({
-        timestamp: it.timestamp,
-        kind: it.kind,
-        json: JSON.stringify(it.payload)
-      }))
-    );
-  }
-
-  /**
-   *
-   * @param session
-   * @param options
-   * @returns
-   */
-  async query(session: number, options: StorageQueryOptions): Promise<Measure[]> {
-    const rows = await this.storage.query(session.toString(), options);
-
-    return rows.map(it => ({
-      timestamp: it.timestamp,
-      kind: it.kind,
-      payload: JSON.parse(it.json)
-    }));
-  }
-}

package/src/store/error.ts

@@ -1,36 +0,0 @@
-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 +0,0 @@
-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';

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

@@ -1,30 +0,0 @@
-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('BalancePatchEvent', () => {
-  test('should patch a store', () => {
-    const base = new Asset('de30', 'cex', 2);
-    const quote = new Asset('usd', 'cex', 2);
-    const timestamp = now();
-    const store = new Store();
-    let component;
-
-    store.changes$.subscribe(it => (component = it));
-
-    store.dispatch(
-      new InstrumentPatchEvent(timestamp, base, quote, new Commission(d.Zero, d.Zero), '')
-    );
-    store.dispatch(new BalancePatchEvent(base, d(100), d.Zero, timestamp));
-
-    const balance = store.snapshot.balance.get(base.id) ?? fail();
-
-    expect(balance).toEqual(component);
-    expect(balance.free).toEqual(d(100));
-    expect(balance.locked).toEqual(d.Zero);
-    expect(balance.timestamp).toEqual(timestamp);
-    expect(store.snapshot.timestamp).toEqual(timestamp);
-  });
-});