@quantform/core 0.6.7 → 0.7.0-beta.5

package/src/storage/feed.ts

@@ -1,124 +0,0 @@
-import { InstrumentSelector } from '@lib/domain';
-import { d } from '@lib/shared';
-import { Storage, StorageDocument, StorageQueryOptions } from '@lib/storage';
-import { OrderbookPatchEvent, TradePatchEvent } from '@lib/store';
-
-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 '@lib/shared';
-import { Storage, StorageQueryOptions } from '@lib/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,47 +0,0 @@
-import { AssetSelector, InstrumentSelector, OrderState } from '@lib/domain';
-
-export class AssetNotSupportedError extends Error {
-  constructor(selector: AssetSelector) {
-    super(`asset ${selector.id} not supported.`);
-  }
-}
-
-export class InstrumentNotSubscribedError extends Error {
-  constructor(selector: InstrumentSelector) {
-    super(`trying to patch a not subscribed instrument ${selector.id}`);
-  }
-}
-
-export class InstrumentNotSupportedError extends Error {
-  constructor(selector: InstrumentSelector) {
-    super(`instrument ${selector.id} not supported.`);
-  }
-}
-
-export class LiquidationError extends Error {
-  constructor() {
-    super('you have been liquidated.');
-  }
-}
-
-export class OrderNotFoundError extends Error {
-  constructor(id: string) {
-    super(`trying to patch unknown order: ${id}`);
-  }
-}
-
-export class BalanceNotFoundError extends Error {
-  constructor(selector: AssetSelector) {
-    super(`balance not found: ${selector.id}`);
-  }
-}
-
-export class OrderInvalidStateError extends Error {
-  constructor(currentState: OrderState, requiredStates: OrderState[]) {
-    super(
-      `order state ${currentState} is not in one of required states: ${requiredStates.join(
-        ', '
-      )}`
-    );
-  }
-}

package/src/store/index.ts

@@ -1,10 +0,0 @@
-export * from '@lib/store/store';
-export * from '@lib/store/store-state';
-export * from '@lib/store/store-balance-event';
-export * from '@lib/store/store-instrument-event';
-export * from '@lib/store/store-order-event';
-export * from '@lib/store/store-orderbook-event';
-export * from '@lib/store/store-position-event';
-export * from '@lib/store/store-trade-event';
-export * from '@lib/store/store-event';
-export * from '@lib/store/error';

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

@@ -1,28 +0,0 @@
-import { Asset, Commission } from '@lib/domain';
-import { d, now } from '@lib/shared';
-import { BalanceLoadEvent, InstrumentPatchEvent, Store } from '@lib/store';
-
-describe(BalanceLoadEvent.name, () => {
-  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 BalanceLoadEvent(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);
-  });
-});

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

@@ -1,72 +0,0 @@
-import { AssetSelector, Balance } from '@lib/domain';
-import { decimal, timestamp } from '@lib/shared';
-import {
-  AssetNotSupportedError,
-  State,
-  StateChangeTracker,
-  StoreEvent
-} from '@lib/store';
-
-/**
- * Updates the free and freezed balance of the given asset.
- */
-export class BalanceLoadEvent implements StoreEvent {
-  constructor(
-    readonly asset: AssetSelector,
-    readonly available: decimal,
-    readonly unavailable: decimal,
-    readonly timestamp: timestamp
-  ) {}
-
-  handle(state: State, changes: StateChangeTracker) {
-    /*
-     * skip not tradeable assets (for example, you can have an unlisted
-     * asset in your wallet).
-     */
-    const asset = state.universe.asset.get(this.asset.id);
-    if (!asset) {
-      return;
-    }
-
-    const balance = state.balance.tryGetOrSet(this.asset.id, () => new Balance(0, asset));
-
-    balance.timestamp = this.timestamp;
-    balance.available = this.available;
-    balance.unavailable = this.unavailable;
-    balance.clearTransientFunding();
-
-    state.timestamp = this.timestamp;
-
-    changes.commit(balance);
-  }
-}
-
-/**
- *
- */
-export class BalancePatchEvent implements StoreEvent {
-  constructor(
-    readonly asset: AssetSelector,
-    readonly available: decimal,
-    readonly unavailable: decimal,
-    readonly timestamp: timestamp
-  ) {}
-
-  handle(state: State, changes: StateChangeTracker) {
-    const asset = state.universe.asset.get(this.asset.id);
-    if (!asset) {
-      throw new AssetNotSupportedError(this.asset);
-    }
-
-    const balance = state.balance.tryGetOrSet(this.asset.id, () => new Balance(0, asset));
-
-    balance.timestamp = this.timestamp;
-    balance.available = this.available;
-    balance.unavailable = this.unavailable;
-    balance.clearTransientFunding();
-
-    state.timestamp = this.timestamp;
-
-    changes.commit(balance);
-  }
-}

package/src/store/store-event.ts

@@ -1,8 +0,0 @@
-import { timestamp } from '@lib/shared';
-import { State, StateChangeTracker } from '@lib/store';
-
-export interface StoreEvent {
-  timestamp: timestamp;
-
-  handle(state: State, changes: StateChangeTracker): void;
-}

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

@@ -1,25 +0,0 @@
-import { Asset, Commission } from '@lib/domain';
-import { d, now } from '@lib/shared';
-import { InstrumentPatchEvent, Store } from '@lib/store';
-
-describe(InstrumentPatchEvent.name, () => {
-  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;
-    const instrument = universe.instrument.get('cex:de30-usd') ?? fail();
-
-    expect(instrument.base).toEqual(base);
-    expect(instrument.quote).toEqual(quote);
-    expect(instrument.timestamp).toEqual(timestamp);
-    expect(universe.instrument.asReadonlyArray().length).toEqual(1);
-    expect(universe.asset.asReadonlyArray().length).toEqual(2);
-  });
-});

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

@@ -1,87 +0,0 @@
-import { Asset, Commission, Instrument, InstrumentSelector } from '@lib/domain';
-import { timestamp } from '@lib/shared';
-import {
-  AssetNotSupportedError,
-  InnerSet,
-  InstrumentNotSupportedError,
-  State,
-  StateChangeTracker,
-  StoreEvent
-} from '@lib/store';
-
-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(0, this.base, this.quote, this.raw, Commission.Zero);
-    });
-
-    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 InstrumentNotSupportedError(this.instrument);
-    }
-
-    if (this.subscribed) {
-      const base = state.universe.asset.get(instrument.base.id);
-      if (!base) {
-        throw new AssetNotSupportedError(instrument.base);
-      }
-
-      const quote = state.universe.asset.get(instrument.quote.id);
-      if (!quote) {
-        throw new AssetNotSupportedError(instrument.quote);
-      }
-
-      state.subscription.instrument.upsert(instrument);
-      state.subscription.asset.upsert(base);
-      state.subscription.asset.upsert(quote);
-    }
-
-    changes.commit(instrument);
-  }
-}

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

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