@quantform/core 0.6.7 → 0.7.0-beta.5

package/src/domain/session.ts

@@ -1,261 +0,0 @@
-import {
-  concat,
-  defer,
-  filter,
-  from,
-  map,
-  mergeMap,
-  Observable,
-  of,
-  ReplaySubject,
-  share,
-  shareReplay,
-  startWith,
-  switchMap,
-  take
-} from 'rxjs';
-import { v4 } from 'uuid';
-
-import { AdapterAggregate } from '@lib/adapter';
-import {
-  AssetSelector,
-  Balance,
-  balance,
-  Instrument,
-  instrument,
-  instruments,
-  InstrumentSelector,
-  InvalidInstrumentSelectorError,
-  Ohlc,
-  Order,
-  order,
-  Orderbook,
-  orderbook,
-  orders,
-  Position,
-  position,
-  positions,
-  Trade,
-  trade
-} from '@lib/domain';
-import { decimal } from '@lib/shared';
-import { Measurement } from '@lib/storage';
-import { Store } from '@lib/store';
-
-type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
-
-export class Session {
-  private initialized = false;
-
-  get timestamp(): number {
-    return this.store.snapshot.timestamp;
-  }
-
-  constructor(
-    readonly id: number,
-    readonly store: Store,
-    readonly aggregate: AdapterAggregate,
-    readonly measurement: Measurement | undefined
-  ) {}
-
-  async awake(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-
-    this.initialized = true;
-
-    // awake all adapters and synchronize trading accounts with store.
-    await this.aggregate.awake();
-  }
-
-  async dispose(): Promise<void> {
-    if (!this.initialized) {
-      return;
-    }
-
-    this.store.dispose();
-
-    await this.aggregate.dispose();
-
-    this.initialized = false;
-  }
-
-  /**
-   * Subscribes to specific instrument. Usually forces adapter to subscribe
-   * for orderbook and ticker streams.
-   */
-  subscribe(instrument: Array<InstrumentSelector>): Promise<void> {
-    return this.aggregate.subscribe(instrument);
-  }
-
-  /**
-   * Opens a new order.
-   */
-  open(order: {
-    instrument: InstrumentSelector;
-    quantity: decimal;
-    rate?: decimal;
-  }): Observable<Readonly<Order>> {
-    const instrument = this.store.snapshot.universe.instrument.get(order.instrument.id);
-    if (!instrument) {
-      throw new InvalidInstrumentSelectorError(order.instrument.id);
-    }
-
-    const newOrder = new Order(
-      this.timestamp,
-      v4(),
-      instrument,
-      order.quantity,
-      this.timestamp,
-      order.rate
-    );
-
-    return of(newOrder).pipe(
-      switchMap(() => this.aggregate.open(newOrder)),
-      switchMap(() =>
-        this.order(order.instrument).pipe(filter(it => it.id == newOrder.id))
-      )
-    );
-  }
-
-  /**
-   * Cancels specific order.
-   */
-  cancel(order: Order): Observable<Readonly<Order>> {
-    return defer(() => from(this.aggregate.cancel(order))).pipe(
-      switchMap(() => this.order(order.instrument).pipe(filter(it => it.id == order.id)))
-    );
-  }
-
-  /**
-   * Subscribes to specific instrument changes.
-   * When adapter awake then it will fetch collection of all available instruments.
-   */
-  instrument(selector: InstrumentSelector): Observable<Readonly<Instrument>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(instrument(selector, this.store.snapshot));
-  }
-
-  /**
-   * Subscribes to instruments changes.
-   * When adapter awake then it will fetch collection of all available instruments.
-   */
-  instruments(): Observable<Readonly<Instrument[]>> {
-    return this.store.changes$.pipe(instruments(this.store.snapshot));
-  }
-
-  /**
-   * Subscribes to balance changes.
-   */
-  balance(selector: AssetSelector): Observable<Readonly<Balance>> {
-    return this.store.changes$.pipe(balance(selector, this.store.snapshot));
-  }
-
-  /**
-   * Subscribes to trade/ticker changes.
-   */
-  trade(selector: InstrumentSelector): Observable<Readonly<Trade>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(trade(selector, this.store.snapshot));
-  }
-
-  /**
-   * Subscribes to orderbook changes.
-   * Right now you can access only best bid and best ask.
-   */
-  orderbook(selector: InstrumentSelector): Observable<Readonly<Orderbook>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(orderbook(selector, this.store.snapshot));
-  }
-
-  /**
-   * Subscribes to position on leveraged market.
-   */
-  position(selector: InstrumentSelector): Observable<Readonly<Position>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(position(selector));
-  }
-
-  /**
-   * Subscribes to positions on leveraged markets.
-   */
-  positions(selector: InstrumentSelector): Observable<Readonly<Position[]>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(positions(selector, this.store.snapshot));
-  }
-
-  order(selector: InstrumentSelector): Observable<Readonly<Order>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(order(selector));
-  }
-
-  orders(selector: InstrumentSelector): Observable<Readonly<Order[]>> {
-    this.subscribe([selector]);
-
-    return this.store.changes$.pipe(orders(selector, this.store.snapshot));
-  }
-
-  history(
-    selector: InstrumentSelector,
-    timeframe: number,
-    length: number
-  ): Observable<Readonly<Ohlc>> {
-    return this.store.changes$.pipe(
-      startWith(this.store.snapshot.universe.instrument.get(selector.id)),
-      filter(it => it !== undefined && it.type === Instrument.type),
-      map(it => it as Instrument),
-      filter(it => it.id === selector.id),
-      switchMap(() => from(this.aggregate.history(selector, timeframe, length))),
-      take(1),
-      shareReplay(),
-      mergeMap(it => it)
-    );
-  }
-
-  measure<T extends { timestamp: number }>(
-    spec: {
-      kind: string;
-      timestamp?: number;
-    },
-    defaultValue?: Optional<T, 'timestamp'>
-  ): [Observable<T>, (value: T) => void] {
-    if (!this.measurement) {
-      throw new Error();
-    }
-
-    const changes$ = new ReplaySubject<Optional<T, 'timestamp'>>();
-    const persisted$ = from(
-      this.measurement.query(this.id, {
-        to: spec.timestamp ?? this.timestamp,
-        kind: spec.kind,
-        count: 1
-      })
-    ).pipe(
-      map(it =>
-        it.length ? { timestamp: it[0].timestamp, ...it[0].payload } : defaultValue
-      ),
-      share()
-    );
-
-    const setter = (value: Optional<T, 'timestamp'>) => {
-      const timestamp = value.timestamp ?? this.timestamp;
-      const measure = { timestamp, kind: spec.kind, payload: value };
-
-      this.measurement?.save(this.id, [measure]);
-
-      changes$.next({ ...value, timestamp });
-    };
-
-    return [
-      concat(persisted$, changes$.asObservable()).pipe(filter(it => it !== undefined)),
-      setter
-    ];
-  }
-}

package/src/domain/trade-operator.spec.ts

@@ -1,30 +0,0 @@
-import { Subject } from 'rxjs';
-
-import { Asset, Commission, Component, Instrument, Trade, trade } from '@lib/domain';
-import { d } from '@lib/shared';
-import { State } from '@lib/store';
-
-describe(trade.name, () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('abc', 'xyz', 4),
-    new Asset('def', 'xyz', 4),
-    'abc-def',
-    Commission.Zero
-  );
-
-  const state = new State();
-
-  beforeEach(() => {
-    state.trade.upsert(new Trade(0, instrument, d.Zero, d.Zero));
-  });
-
-  test('should pipe an orderbook on subscription', done => {
-    new Subject<Component>().pipe(trade(instrument, state)).subscribe({
-      next: it => {
-        expect(it.id).toEqual(instrument.id);
-        done();
-      }
-    });
-  });
-});

package/src/domain/trade-operator.ts

@@ -1,14 +0,0 @@
-import { filter, map, Observable, startWith } from 'rxjs';
-
-import { Component, InstrumentSelector, Trade } from '@lib/domain';
-import { State } from '@lib/store';
-
-export function trade(selector: InstrumentSelector, state: State) {
-  return (source$: Observable<Component>) =>
-    source$.pipe(
-      startWith(state.trade.get(selector.id)),
-      filter(it => it !== undefined && it.type === Trade.type),
-      map(it => it as Trade),
-      filter(it => it.instrument.id === selector.id)
-    );
-}

package/src/domain/trade.spec.ts

@@ -1,18 +0,0 @@
-import { Asset, Commission, Instrument, Trade } from '@lib/domain';
-import { d } from '@lib/shared';
-
-describe(Trade.name, () => {
-  const instrument = new Instrument(
-    0,
-    new Asset('abc', 'xyz', 4),
-    new Asset('def', 'xyz', 4),
-    'abc-def',
-    Commission.Zero
-  );
-
-  test('should construct an empty trade', () => {
-    const sut = new Trade(0, instrument, d.Zero, d.Zero);
-
-    expect(sut.id).toEqual(instrument.id);
-  });
-});

package/src/domain/trade.ts

@@ -1,22 +0,0 @@
-import { Component, Instrument } from '@lib/domain';
-import { decimal, hash } from '@lib/shared';
-
-/**
- * Simple trade or ticker executed on the market, it's a match of buyer
- * and seller of the same asset.
- */
-export class Trade implements Component {
-  static type = hash(Trade.name);
-  readonly type = Trade.type;
-
-  readonly id: string;
-
-  constructor(
-    public timestamp: number,
-    public readonly instrument: Instrument,
-    public rate: decimal,
-    public quantity: decimal
-  ) {
-    this.id = instrument.id;
-  }
-}

package/src/shared/collections.spec.ts

@@ -1,34 +0,0 @@
-import { Liquidity, LiquidityAskComparer } from '@lib/domain';
-import { d, PriorityList } from '@lib/shared';
-
-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/hash.ts

@@ -1,10 +0,0 @@
-export function hash(str: string): number {
-  let hash = 7373;
-  let i = str.length;
-
-  while (i) {
-    hash = (hash * 77) ^ str.charCodeAt(--i);
-  }
-
-  return hash >>> 0;
-}

package/src/shared/logger.ts

@@ -1,46 +0,0 @@
-import chalk from 'chalk';
-
-import { now } from '@lib/shared';
-
-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 {
-  constructor(private readonly context: string) {}
-
-  public info = (message: any, ...params: unknown[]) =>
-    params?.length
-      ? console.info(`${this.prefix()}: ${message}`, params)
-      : console.info(`${this.prefix()}: ${message}`);
-
-  public debug = (message: any, ...params: unknown[]) =>
-    params?.length
-      ? console.debug(`${this.prefix()}: ${message}`, params)
-      : console.debug(`${this.prefix()}: ${message}`);
-
-  public warn = (message: any, ...params: unknown[]) =>
-    params?.length
-      ? console.warn(`${this.prefix()}: ${message}`, params)
-      : console.warn(`${this.prefix()}: ${message}`);
-
-  public error = (message: any, ...params: unknown[]) =>
-    params?.length
-      ? console.error(`${this.prefix()}: ${message}`, params)
-      : console.error(`${this.prefix()}: ${message}`);
-
-  public prefix = () => `${time()} ${colorize(this.context)}`;
-}
-
-export function log(context: string): Logger {
-  return new Logger(context);
-}

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,17 +0,0 @@
-import { Cache, InMemoryStorage } from '@lib/storage';
-
-describe(Cache.name, () => {
-  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 '@lib/shared';
-import { Storage } from '@lib/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);
-  }
-}