@quantform/core 0.5.14 → 0.5.15

package/src/storage/feed.ts

@@ -1,4 +1,4 @@
-import { InstrumentSelector } from '../domain';
+import { Candle, InstrumentSelector } from '../domain';
 import { StoreEvent } from '../store';
 import { Storage, StorageQueryOptions } from './storage';
 
@@ -19,18 +19,22 @@ export class Feed {
   /**
    *
    * @param instrument
-   * @param events
+   * @param candles
    * @returns
    */
-  save(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void> {
+  save(instrument: InstrumentSelector, candles: Candle[]): Promise<void> {
     return this.storage.save(
       instrument.toString(),
-      events.map(it => ({
+      candles.map(it => ({
         timestamp: it.timestamp,
-        kind: it.type,
-        json: JSON.stringify(it, (key, value) =>
-          key != 'timestamp' && key != 'type' && key != 'instrument' ? value : undefined
-        )
+        kind: 'candle',
+        json: JSON.stringify({
+          o: it.open,
+          h: it.high,
+          l: it.low,
+          c: it.close,
+          v: it.volume
+        })
       }))
     );
   }
@@ -44,14 +48,20 @@ export class Feed {
   async query(
     instrument: InstrumentSelector,
     options: StorageQueryOptions
-  ): Promise<StoreEvent[]> {
-    const rows = await this.storage.query(instrument.toString(), options);
+  ): Promise<Candle[]> {
+    const rows = await this.storage.query(instrument.id, options);
 
-    return rows.map(it => ({
-      timestamp: it.timestamp,
-      type: it.kind,
-      instrument,
-      ...JSON.parse(it.json)
-    }));
+    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
+      );
+    });
   }
 }

package/src/storage/storage.ts

@@ -11,6 +11,11 @@ export type StorageQueryOptions = {
   count: number;
 };
 
+/**
+ *
+ */
+export type StorageFactory = (type: string) => Storage;
+
 /**
  *
  */
@@ -35,11 +40,10 @@ export interface Storage {
   query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]>;
 }
 
-/**
- *
- */
-export interface StorageFactory {
-  create(type: string): Storage;
+export function inMemoryStorageFactory(): StorageFactory {
+  const storage: Record<string, Storage> = {};
+
+  return (type: string) => storage[type] ?? (storage[type] = new InMemoryStorage());
 }
 
 /**
@@ -118,11 +122,3 @@ export class InMemoryStorage implements Storage {
     this.tables = {};
   }
 }
-
-export class InMemoryStorageFactory implements StorageFactory {
-  private readonly storage: Record<string, Storage> = {};
-
-  create(type: string): Storage {
-    return this.storage[type] ?? (this.storage[type] = new InMemoryStorage());
-  }
-}

package/src/store/index.ts

@@ -1,3 +1,9 @@
-export * from './event';
 export * from './store';
-export * from './store.state';
+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/{event/store-balance.event.spec.ts → store-balance.event.spec.ts}

@@ -1,10 +1,10 @@
-import { Asset, Commission } from '../../domain';
-import { now } from '../../shared';
-import { Store } from '..';
-import { BalancePatchEvent } from '.';
+import { Asset, Commission } from '../domain';
+import { now } from '../shared';
+import { Store } from '.';
+import { BalancePatchEvent } from './store-balance.event';
 import { InstrumentPatchEvent } from './store-instrument.event';
 
-describe('balance event tests', () => {
+describe('BalancePatchEvent', () => {
   test('should patch a store', () => {
     const base = new Asset('de30', 'cex', 2);
     const quote = new Asset('usd', 'cex', 2);
@@ -19,7 +19,7 @@ describe('balance event tests', () => {
     );
     store.dispatch(new BalancePatchEvent(base, 100, 0, timestamp));
 
-    const balance = store.snapshot.balance[base.toString()];
+    const balance = store.snapshot.balance.get(base.id);
 
     expect(balance).toEqual(component);
     expect(balance.free).toEqual(100);

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

@@ -0,0 +1,124 @@
+import { AssetSelector, Balance, InstrumentSelector } from '../domain';
+import { timestamp } from '../shared';
+import { StoreEvent } from './store.event';
+import { State, StateChangeTracker } from './store-state';
+
+/**
+ * Updates the free and freezed balance of the given asset.
+ */
+export class BalancePatchEvent implements StoreEvent {
+  constructor(
+    readonly asset: AssetSelector,
+    readonly free: number,
+    readonly freezed: number,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker) {
+    // you can have not tradeable assets in wallet, skip them.
+    const asset = state.universe.asset.get(this.asset.id);
+    if (!asset) {
+      return;
+    }
+
+    const balance = state.balance.tryGetOrSet(this.asset.id, () => new Balance(asset));
+
+    balance.timestamp = this.timestamp;
+    balance.set(this.free, this.freezed);
+
+    state.timestamp = this.timestamp;
+
+    changes.commit(balance);
+  }
+}
+/**
+ *
+ */
+export class BalanceTransactEvent implements StoreEvent {
+  constructor(
+    readonly asset: AssetSelector,
+    readonly amount: number,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker) {
+    const balance = state.balance.tryGetOrSet(this.asset.id, () => {
+      const asset = state.universe.asset.get(this.asset.id);
+
+      return new Balance(asset);
+    });
+
+    balance.timestamp = this.timestamp;
+    balance.account(this.amount);
+
+    state.timestamp = this.timestamp;
+
+    changes.commit(balance);
+  }
+}
+
+/**
+ *
+ */
+export class BalanceLockOrderEvent implements StoreEvent {
+  constructor(
+    readonly orderId: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker) {
+    const order = state.order.get(this.instrument.id).get(this.orderId);
+    const base = state.balance.get(order.instrument.base.id);
+    const quote = state.balance.get(order.instrument.quote.id);
+
+    const balanceToLock = order.calculateBalanceToLock(base, quote);
+
+    state.timestamp = this.timestamp;
+
+    if (balanceToLock.base > 0) {
+      base.timestamp = this.timestamp;
+      base.lock(this.orderId, balanceToLock.base);
+
+      changes.commit(base);
+    }
+
+    if (balanceToLock.quote > 0) {
+      quote.timestamp = this.timestamp;
+      quote.lock(this.orderId, balanceToLock.quote);
+
+      changes.commit(quote);
+    }
+  }
+}
+
+/**
+ *
+ */
+export class BalanceUnlockOrderEvent implements StoreEvent {
+  constructor(
+    readonly orderId: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker) {
+    const order = state.order.get(this.instrument.id).get(this.orderId);
+    const base = state.balance.get(order.instrument.base.id);
+    const quote = state.balance.get(order.instrument.quote.id);
+
+    state.timestamp = this.timestamp;
+
+    if (base.tryUnlock(this.orderId)) {
+      base.timestamp = this.timestamp;
+
+      changes.commit(base);
+    }
+
+    if (quote.tryUnlock(this.orderId)) {
+      quote.timestamp = this.timestamp;
+
+      changes.commit(quote);
+    }
+  }
+}

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

@@ -0,0 +1,25 @@
+import { Store } from '..';
+import { Asset, Commission } from '../domain';
+import { now } from '../shared';
+import { InstrumentPatchEvent } from './store-instrument.event';
+
+describe('InstrumentPatchEvent', () => {
+  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(0, 0), '')
+    );
+
+    const { universe } = store.snapshot;
+
+    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(universe.instrument.asReadonlyArray().length).toEqual(1);
+    expect(universe.asset.asReadonlyArray().length).toEqual(2);
+  });
+});

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

@@ -0,0 +1,72 @@
+import { Asset, Commission, InstrumentSelector, Instrument } from '../domain';
+import { timestamp } from '../shared';
+import { State, StateChangeTracker } from '../store';
+import { InnerSet } from './store-state';
+import { StoreEvent } from './store.event';
+
+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(this.base, this.quote, this.raw);
+    });
+
+    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 Error('invalid instrument');
+    }
+
+    if (this.subscribed) {
+      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));
+    }
+
+    changes.commit(instrument);
+  }
+}

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

@@ -0,0 +1,28 @@
+import { Asset, Instrument, Order } from '../domain';
+import { now } from '../shared';
+import { Store } from '../store';
+import { OrderLoadEvent } from './store-order.event';
+
+const instrument = new Instrument(
+  new Asset('btc', 'binance', 8),
+  new Asset('usdt', 'binance', 2),
+  'binance:btc-usdt'
+);
+
+describe('OrderLoadEvent', () => {
+  test('should load order to store', () => {
+    const timestamp = now();
+    const store = new Store();
+    const order = Order.market(instrument, 1.0);
+
+    order.state = 'PENDING';
+
+    store.snapshot.universe.instrument.upsert(instrument);
+    store.snapshot.subscription.instrument.upsert(instrument);
+
+    store.dispatch(new OrderLoadEvent(order, timestamp));
+
+    expect(store.snapshot.order.asReadonlyArray().length).toEqual(1);
+    expect(store.snapshot.order.get(instrument.id).get(order.id)).toEqual(order);
+  });
+});

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

@@ -0,0 +1,214 @@
+import { InstrumentSelector, Order } from '../domain';
+import { timestamp } from '../shared';
+import { StoreEvent } from './store.event';
+import { InnerSet, State, StateChangeTracker } from './store-state';
+
+export class OrderLoadEvent implements StoreEvent {
+  constructor(readonly order: Order, readonly timestamp: timestamp) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    this.order.timestamp = this.timestamp;
+
+    const orderByInstrument = state.order.tryGetOrSet(
+      this.order.instrument.id,
+      () => new InnerSet<Order>(this.order.instrument.id)
+    );
+
+    orderByInstrument.upsert(this.order);
+  }
+}
+
+export class OrderNewEvent implements StoreEvent {
+  constructor(readonly order: Order, readonly timestamp: timestamp) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    if (this.order.state != 'NEW') {
+      throw new Error(`Order is not new`);
+    }
+
+    this.order.createdAt = this.timestamp;
+    this.order.timestamp = this.timestamp;
+
+    const orderByInstrument = state.order.tryGetOrSet(
+      this.order.instrument.id,
+      () => new InnerSet<Order>(this.order.instrument.id)
+    );
+
+    orderByInstrument.upsert(this.order);
+
+    changes.commit(this.order);
+  }
+}
+
+export class OrderPendingEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const order = state.order
+      .tryGetOrSet(this.instrument.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      })
+      .tryGetOrSet(this.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      });
+
+    if (order.state != 'NEW') {
+      throw new Error(`Order is not NEW: ${order.state}`);
+    }
+
+    order.state = 'PENDING';
+    order.timestamp = this.timestamp;
+
+    changes.commit(order);
+  }
+}
+
+export class OrderFilledEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: InstrumentSelector,
+    readonly averageExecutionRate: number,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const order = state.order
+      .tryGetOrSet(this.instrument.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      })
+      .tryGetOrSet(this.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      });
+
+    if (order.state != 'PENDING' && order.state != 'CANCELING') {
+      throw new Error(`Order is not PENDING or CANCELING: ${order.state}`);
+    }
+
+    order.state = 'FILLED';
+    order.timestamp = this.timestamp;
+    order.quantityExecuted = order.quantity;
+    order.averageExecutionRate = this.averageExecutionRate;
+
+    changes.commit(order);
+  }
+}
+
+export class OrderCancelingEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const order = state.order
+      .tryGetOrSet(this.instrument.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      })
+      .tryGetOrSet(this.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      });
+
+    if (order.state == 'CANCELING' || order.state == 'CANCELED') {
+      return;
+    }
+
+    if (order.state != 'PENDING') {
+      throw new Error(`Order is not PENDING: ${order.state}`);
+    }
+
+    order.state = 'CANCELING';
+    order.timestamp = this.timestamp;
+
+    changes.commit(order);
+  }
+}
+
+export class OrderCanceledEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const order = state.order
+      .tryGetOrSet(this.instrument.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      })
+      .tryGetOrSet(this.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      });
+
+    if (order.state == 'CANCELED') {
+      return;
+    }
+
+    if (order.state != 'CANCELING') {
+      throw new Error(`Order is not CANCELING: ${order.state}`);
+    }
+
+    order.state = 'CANCELED';
+    order.timestamp = this.timestamp;
+
+    changes.commit(order);
+  }
+}
+
+export class OrderCancelFailedEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const order = state.order
+      .tryGetOrSet(this.instrument.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      })
+      .tryGetOrSet(this.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      });
+
+    if (order.state != 'CANCELING') {
+      return;
+    }
+
+    order.state = 'PENDING';
+    order.timestamp = this.timestamp;
+
+    changes.commit(order);
+  }
+}
+
+export class OrderRejectedEvent implements StoreEvent {
+  constructor(
+    readonly id: string,
+    readonly instrument: InstrumentSelector,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    const order = state.order
+      .tryGetOrSet(this.instrument.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      })
+      .tryGetOrSet(this.id, () => {
+        throw new Error(`Trying to patch unknown order: ${this.id}`);
+      });
+
+    if (order.state != 'NEW') {
+      throw new Error(`Order is not NEW: ${order.state}`);
+    }
+
+    order.state = 'REJECTED';
+    order.timestamp = this.timestamp;
+
+    changes.commit(order);
+  }
+}

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

@@ -0,0 +1,54 @@
+import { InstrumentSelector, Orderbook } from '../domain';
+import { timestamp } from '../shared';
+import { StoreEvent } from './store.event';
+import { State, StateChangeTracker } from './store-state';
+
+export class OrderbookPatchEvent implements StoreEvent {
+  constructor(
+    readonly instrument: InstrumentSelector,
+    readonly bestAskRate: number,
+    readonly bestAskQuantity: number,
+    readonly bestBidRate: number,
+    readonly bestBidQuantity: number,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    if (!state.subscription.instrument.get(this.instrument.id)) {
+      throw new Error(`Trying to patch unsubscribed instrument: ${this.instrument.id}`);
+    }
+
+    const orderbook = state.orderbook.tryGetOrSet(
+      this.instrument.id,
+      () => new Orderbook(state.universe.instrument.get(this.instrument.id))
+    );
+
+    state.timestamp = this.timestamp;
+
+    orderbook.timestamp = this.timestamp;
+    orderbook.bestAskRate = orderbook.instrument.quote.fixed(this.bestAskRate);
+    orderbook.bestAskQuantity = orderbook.instrument.base.fixed(this.bestAskQuantity);
+    orderbook.bestBidRate = orderbook.instrument.quote.fixed(this.bestBidRate);
+    orderbook.bestBidQuantity = orderbook.instrument.base.fixed(this.bestBidQuantity);
+
+    const quote = state.balance.get(orderbook.instrument.quote.id);
+
+    if (quote) {
+      for (const position of Object.values(quote.position)) {
+        if (position.instrument.id != orderbook.instrument.id) {
+          continue;
+        }
+
+        const rate = position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
+
+        position.calculateEstimatedUnrealizedPnL(rate);
+      }
+
+      if (quote.total < 0) {
+        throw new Error('liquidated');
+      }
+    }
+
+    changes.commit(orderbook);
+  }
+}