@quantform/core 0.5.23 → 0.6.5

package/src/index.ts

@@ -1,7 +1,80 @@
+import chalk from 'chalk';
+import { finalize, forkJoin, Observable, of, switchMap } from 'rxjs';
+
+import { Session, SessionBuilder, SessionFeature } from './domain';
 export * from './adapter';
-export * from './bootstrap';
 export * from './domain';
-export * from './indicator';
 export * from './shared';
 export * from './storage';
 export * from './store';
+
+import { Logger } from './shared';
+
+const registry: Record<string, () => Array<SessionFeature>> = {};
+
+export type SessionHook = (session: Session) => Observable<any>;
+
+/**
+ * Describes a single strategy logic
+ */
+export let rule: (name: string | undefined, describe: SessionHook) => void;
+
+/**
+ *
+ */
+export let beforeAll: (describe: SessionHook) => void;
+
+/**
+ *
+ * @param name
+ * @param describe
+ */
+export function describe(name: string, describe: () => Array<SessionFeature>) {
+  registry[name] = describe;
+}
+
+/**
+ *
+ * @param name
+ * @param builder
+ * @returns
+ */
+export async function spawn(name: string, builder: SessionBuilder) {
+  const describe = registry[name];
+  if (!describe) {
+    throw new Error(`missing strategy: ${name}`);
+  }
+
+  const ruleHooks = new Array<SessionHook>();
+  const beforeAllHooks = new Array<SessionHook>();
+
+  beforeAll = (describe: SessionHook) => {
+    beforeAllHooks.push(describe);
+  };
+
+  rule = (ruleName: string | undefined, describe: SessionHook) => {
+    if (ruleName) {
+      Logger.info(name, `${chalk.italic(ruleName)} rule found`);
+    }
+
+    ruleHooks.push(describe);
+  };
+
+  for (const feature of describe()) {
+    feature(builder);
+  }
+
+  return (session: Session) => {
+    const beforeAll$ = beforeAllHooks.map(it => it(session));
+    const rule$ = ruleHooks.map(it => it(session));
+
+    if (!beforeAll$.length) {
+      beforeAll$.push(of(true));
+    }
+
+    return forkJoin(beforeAll$).pipe(
+      switchMap(() => forkJoin(rule$)),
+      finalize(() => session.dispose())
+    );
+  };
+}

package/src/shared/collections.spec.ts

@@ -1,4 +1,4 @@
-import { Liquidity, LiquidityAskComparer } from '..';
+import { Liquidity, LiquidityAskComparer } from '../domain';
 import { d, PriorityList } from '.';
 
 describe('PriorityList', () => {
@@ -15,16 +15,20 @@ describe('PriorityList', () => {
       { rate: d(5), quantity: d(0) }
     ];
 
-    const sut = new PriorityList<Liquidity>(LiquidityAskComparer, 'rate');
+    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);
 
-    expect(sut.head.rate).toEqual(d(2));
-    expect(sut.head.quantity).toEqual(d(3));
+    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(2).quantity).toEqual(d(3));
-    expect(sut.getByKey(3)).toEqual(undefined);
+    expect(sut.getByKey(d(2).toString()).quantity).toEqual(d(3));
+    expect(sut.getByKey(d(3).toString())).toEqual(undefined);
   });
 });

package/src/shared/collections.ts

@@ -16,42 +16,53 @@ 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 }> {
-  private valueByKey: Record<any, T> = {};
+export class PriorityList<T extends { next: T | undefined }> {
+  private valueByKey: Record<string, T> = {};
 
-  head: T;
+  head: T | undefined;
 
   constructor(
     private readonly comparer: (lhs: Omit<T, 'next'>, rhs: Omit<T, 'next'>) => number,
-    private readonly key: keyof Omit<T, 'next'>
+    private readonly getKeyFn: (key: Omit<T, 'next'>) => string
   ) {}
 
-  getByKey(key: any): T {
+  getByKey(key: string): T {
     return this.valueByKey[key];
   }
 
-  private make(value: Omit<T, 'next'>, next: T = undefined): T {
+  private make(value: Omit<T, 'next'>, next: T | undefined = undefined): T {
     const node = { ...value, next } as T;
 
-    this.valueByKey[node[this.key].toString()] = node;
+    this.valueByKey[this.getKeyFn(node)] = node;
 
     return node;
   }
@@ -98,17 +109,19 @@ export class PriorityList<T extends { next: T }> {
     if (this.comparer(this.head, value) == 0) {
       this.head = this.head.next;
 
-      delete this.valueByKey[value[this.key].toString()];
+      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[value[this.key].toString()];
+        delete this.valueByKey[this.getKeyFn(value)];
 
-        return false;
+        return true;
       }
+
+      return false;
     });
   }
 

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,6 @@
 export * from './datetime';
 export * from './decimals';
-export * from './io';
+export * from './environment';
 export * from './logger';
 export * from './policy';
 export * from './collections';

package/src/shared/logger.ts

@@ -1,9 +1,39 @@
+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(`${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,6 +1,6 @@
 import { filter, map, Observable } from 'rxjs';
 
-// tslint:disable-next-line: no-any
+// 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>) {

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

@@ -118,5 +118,7 @@ export class Feed {
         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';

package/src/store/{store-balance.event.spec.ts → store-balance-event.spec.ts}

@@ -1,8 +1,8 @@
 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';
+import { BalancePatchEvent } from './store-balance-event';
+import { InstrumentPatchEvent } from './store-instrument-event';
 
 describe('BalancePatchEvent', () => {
   test('should patch a store', () => {
@@ -19,7 +19,7 @@ describe('BalancePatchEvent', () => {
     );
     store.dispatch(new BalancePatchEvent(base, d(100), d.Zero, timestamp));
 
-    const balance = store.snapshot.balance.get(base.id);
+    const balance = store.snapshot.balance.get(base.id) ?? fail();
 
     expect(balance).toEqual(component);
     expect(balance.free).toEqual(d(100));

package/src/store/{store-balance.event.ts → store-balance-event.ts}

@@ -1,6 +1,12 @@
 import { AssetSelector, Balance, InstrumentSelector } from '../domain';
 import { decimal, timestamp } from '../shared';
-import { StoreEvent } from './store.event';
+import {
+  assetNotSupportedError,
+  balanceNotFoundError,
+  instrumentNotSubscribedError,
+  orderNotFoundError
+} from './error';
+import { StoreEvent } from './store-event';
 import { State, StateChangeTracker } from './store-state';
 
 /**
@@ -15,13 +21,16 @@ export class BalancePatchEvent implements StoreEvent {
   ) {}
 
   handle(state: State, changes: StateChangeTracker) {
-    // you can have not tradeable assets in wallet, skip them.
+    /*
+     * 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(asset));
+    const balance = state.balance.tryGetOrSet(this.asset.id, () => new Balance(0, asset));
 
     balance.timestamp = this.timestamp;
     balance.set(this.free, this.freezed);
@@ -31,6 +40,7 @@ export class BalancePatchEvent implements StoreEvent {
     changes.commit(balance);
   }
 }
+
 /**
  *
  */
@@ -42,11 +52,12 @@ export class BalanceTransactEvent implements StoreEvent {
   ) {}
 
   handle(state: State, changes: StateChangeTracker) {
-    const balance = state.balance.tryGetOrSet(this.asset.id, () => {
-      const asset = state.universe.asset.get(this.asset.id);
+    const asset = state.universe.asset.get(this.asset.id);
+    if (!asset) {
+      throw assetNotSupportedError(this.asset);
+    }
 
-      return new Balance(asset);
-    });
+    const balance = state.balance.tryGetOrSet(this.asset.id, () => new Balance(0, asset));
 
     balance.timestamp = this.timestamp;
     balance.account(this.amount);
@@ -68,22 +79,38 @@ export class BalanceLockOrderEvent implements StoreEvent {
   ) {}
 
   handle(state: State, changes: StateChangeTracker) {
-    const order = state.order.get(this.instrument.id).get(this.orderId);
+    const orders = state.order.get(this.instrument.id);
+    if (!orders) {
+      throw instrumentNotSubscribedError(this.instrument);
+    }
+
+    const order = orders.get(this.orderId);
+    if (!order) {
+      throw orderNotFoundError(this.orderId);
+    }
+
     const base = state.balance.get(order.instrument.base.id);
+    if (!base) {
+      throw balanceNotFoundError(order.instrument.base);
+    }
+
     const quote = state.balance.get(order.instrument.quote.id);
+    if (!quote) {
+      throw balanceNotFoundError(order.instrument.quote);
+    }
 
     const balanceToLock = order.calculateBalanceToLock(base, quote);
 
     state.timestamp = this.timestamp;
 
-    if (balanceToLock.base.greaterThan(0)) {
+    if (balanceToLock.base?.greaterThan(0)) {
       base.timestamp = this.timestamp;
       base.lock(this.orderId, balanceToLock.base);
 
       changes.commit(base);
     }
 
-    if (balanceToLock.quote.greaterThan(0)) {
+    if (balanceToLock.quote?.greaterThan(0)) {
       quote.timestamp = this.timestamp;
       quote.lock(this.orderId, balanceToLock.quote);
 
@@ -103,9 +130,25 @@ export class BalanceUnlockOrderEvent implements StoreEvent {
   ) {}
 
   handle(state: State, changes: StateChangeTracker) {
-    const order = state.order.get(this.instrument.id).get(this.orderId);
+    const orders = state.order.get(this.instrument.id);
+    if (!orders) {
+      throw instrumentNotSubscribedError(this.instrument);
+    }
+
+    const order = orders.get(this.orderId);
+    if (!order) {
+      throw orderNotFoundError(this.orderId);
+    }
+
     const base = state.balance.get(order.instrument.base.id);
+    if (!base) {
+      throw balanceNotFoundError(order.instrument.base);
+    }
+
     const quote = state.balance.get(order.instrument.quote.id);
+    if (!quote) {
+      throw balanceNotFoundError(order.instrument.quote);
+    }
 
     state.timestamp = this.timestamp;
 

package/src/store/{store-instrument.event.spec.ts → store-instrument-event.spec.ts}

@@ -1,7 +1,7 @@
-import { Store } from '..';
 import { Asset, Commission } from '../domain';
 import { d, now } from '../shared';
-import { InstrumentPatchEvent } from './store-instrument.event';
+import { Store } from './store';
+import { InstrumentPatchEvent } from './store-instrument-event';
 
 describe('InstrumentPatchEvent', () => {
   test('should patch a store', () => {
@@ -15,10 +15,11 @@ describe('InstrumentPatchEvent', () => {
     );
 
     const { universe } = store.snapshot;
+    const instrument = universe.instrument.get('cex:de30-usd') ?? fail();
 
-    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(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 → store-instrument-event.ts}

@@ -1,7 +1,8 @@
 import { Asset, Commission, Instrument, InstrumentSelector } from '../domain';
 import { timestamp } from '../shared';
-import { State, StateChangeTracker } from '../store';
-import { StoreEvent } from './store.event';
+import { State, StateChangeTracker } from '.';
+import { assetNotSupportedError, instrumentNotSupportedError } from './error';
+import { StoreEvent } from './store-event';
 import { InnerSet } from './store-state';
 
 export class InstrumentPatchEvent implements StoreEvent {
@@ -34,7 +35,7 @@ export class InstrumentPatchEvent implements StoreEvent {
 
       state.order.tryGetOrSet(selector.id, () => new InnerSet(selector.id));
 
-      return new Instrument(this.base, this.quote, this.raw);
+      return new Instrument(0, this.base, this.quote, this.raw, Commission.Zero);
     });
 
     instrument.timestamp = this.timestamp;
@@ -58,13 +59,23 @@ export class InstrumentSubscriptionEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const instrument = state.universe.instrument.get(this.instrument.id);
     if (!instrument) {
-      throw new Error('invalid instrument');
+      throw instrumentNotSupportedError(this.instrument);
     }
 
     if (this.subscribed) {
+      const base = state.universe.asset.get(instrument.base.id);
+      if (!base) {
+        throw assetNotSupportedError(instrument.base);
+      }
+
+      const quote = state.universe.asset.get(instrument.quote.id);
+      if (!quote) {
+        throw assetNotSupportedError(instrument.quote);
+      }
+
       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));
+      state.subscription.asset.upsert(base);
+      state.subscription.asset.upsert(quote);
     }
 
     changes.commit(instrument);

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

@@ -0,0 +1,32 @@
+import { Asset, Commission, Instrument, Order } from '../domain';
+import { d, now } from '../shared';
+import { Store } from '.';
+import { OrderLoadEvent } from './store-order-event';
+
+describe('OrderLoadEvent', () => {
+  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 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.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);
+  });
+});