@quantform/core 0.6.5 → 0.6.7

package/src/store/error.ts

@@ -1,36 +1,47 @@
-import { AssetSelector, InstrumentSelector, OrderState } from '../domain';
+import { AssetSelector, InstrumentSelector, OrderState } from '@lib/domain';
 
-export function assetNotSupportedError(selector: AssetSelector) {
-  return new Error(`asset ${selector.id} not supported.`);
+export class AssetNotSupportedError extends Error {
+  constructor(selector: AssetSelector) {
+    super(`asset ${selector.id} not supported.`);
+  }
 }
 
-export function instrumentNotSubscribedError(selector: InstrumentSelector) {
-  return new Error(`trying to patch a not subscribed instrument ${selector.id}`);
+export class InstrumentNotSubscribedError extends Error {
+  constructor(selector: InstrumentSelector) {
+    super(`trying to patch a not subscribed instrument ${selector.id}`);
+  }
 }
 
-export function instrumentNotSupportedError(selector: InstrumentSelector) {
-  return new Error(`instrument ${selector.id} not supported.`);
+export class InstrumentNotSupportedError extends Error {
+  constructor(selector: InstrumentSelector) {
+    super(`instrument ${selector.id} not supported.`);
+  }
 }
 
-export function liquidationError() {
-  return new Error('you have been liquidated.');
+export class LiquidationError extends Error {
+  constructor() {
+    super('you have been liquidated.');
+  }
 }
 
-export function orderNotFoundError(id: string) {
-  return new Error(`trying to patch unknown order: ${id}`);
+export class OrderNotFoundError extends Error {
+  constructor(id: string) {
+    super(`trying to patch unknown order: ${id}`);
+  }
 }
 
-export function balanceNotFoundError(selector: AssetSelector) {
-  return new Error(`balance not found: ${selector.id}`);
+export class BalanceNotFoundError extends Error {
+  constructor(selector: AssetSelector) {
+    super(`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(
-      ', '
-    )}`
-  );
+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,9 +1,10 @@
-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 '@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,10 +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 { Asset, Commission } from '@lib/domain';
+import { d, now } from '@lib/shared';
+import { BalanceLoadEvent, InstrumentPatchEvent, Store } from '@lib/store';
 
-describe('BalancePatchEvent', () => {
+describe(BalanceLoadEvent.name, () => {
   test('should patch a store', () => {
     const base = new Asset('de30', 'cex', 2);
     const quote = new Asset('usd', 'cex', 2);
@@ -17,7 +15,7 @@ describe('BalancePatchEvent', () => {
     store.dispatch(
       new InstrumentPatchEvent(timestamp, base, quote, new Commission(d.Zero, d.Zero), '')
     );
-    store.dispatch(new BalancePatchEvent(base, d(100), d.Zero, timestamp));
+    store.dispatch(new BalanceLoadEvent(base, d(100), d.Zero, timestamp));
 
     const balance = store.snapshot.balance.get(base.id) ?? fail();
 

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

@@ -1,22 +1,20 @@
-import { AssetSelector, Balance, InstrumentSelector } from '../domain';
-import { decimal, timestamp } from '../shared';
+import { AssetSelector, Balance } from '@lib/domain';
+import { decimal, timestamp } from '@lib/shared';
 import {
-  assetNotSupportedError,
-  balanceNotFoundError,
-  instrumentNotSubscribedError,
-  orderNotFoundError
-} from './error';
-import { StoreEvent } from './store-event';
-import { State, StateChangeTracker } from './store-state';
+  AssetNotSupportedError,
+  State,
+  StateChangeTracker,
+  StoreEvent
+} from '@lib/store';
 
 /**
  * Updates the free and freezed balance of the given asset.
  */
-export class BalancePatchEvent implements StoreEvent {
+export class BalanceLoadEvent implements StoreEvent {
   constructor(
     readonly asset: AssetSelector,
-    readonly free: decimal,
-    readonly freezed: decimal,
+    readonly available: decimal,
+    readonly unavailable: decimal,
     readonly timestamp: timestamp
   ) {}
 
@@ -33,7 +31,9 @@ export class BalancePatchEvent implements StoreEvent {
     const balance = state.balance.tryGetOrSet(this.asset.id, () => new Balance(0, asset));
 
     balance.timestamp = this.timestamp;
-    balance.set(this.free, this.freezed);
+    balance.available = this.available;
+    balance.unavailable = this.unavailable;
+    balance.clearTransientFunding();
 
     state.timestamp = this.timestamp;
 
@@ -44,124 +44,29 @@ export class BalancePatchEvent implements StoreEvent {
 /**
  *
  */
-export class BalanceTransactEvent implements StoreEvent {
+export class BalancePatchEvent implements StoreEvent {
   constructor(
     readonly asset: AssetSelector,
-    readonly amount: decimal,
+    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 assetNotSupportedError(this.asset);
+      throw new AssetNotSupportedError(this.asset);
     }
 
     const balance = state.balance.tryGetOrSet(this.asset.id, () => new Balance(0, asset));
 
     balance.timestamp = this.timestamp;
-    balance.account(this.amount);
+    balance.available = this.available;
+    balance.unavailable = this.unavailable;
+    balance.clearTransientFunding();
 
     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 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)) {
-      base.timestamp = this.timestamp;
-      base.lock(this.orderId, balanceToLock.base);
-
-      changes.commit(base);
-    }
-
-    if (balanceToLock.quote?.greaterThan(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 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;
-
-    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-event.ts

@@ -1,5 +1,5 @@
-import { timestamp } from '../shared';
-import { State, StateChangeTracker } from './store-state';
+import { timestamp } from '@lib/shared';
+import { State, StateChangeTracker } from '@lib/store';
 
 export interface StoreEvent {
   timestamp: timestamp;

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

@@ -1,9 +1,8 @@
-import { Asset, Commission } from '../domain';
-import { d, now } from '../shared';
-import { Store } from './store';
-import { InstrumentPatchEvent } from './store-instrument-event';
+import { Asset, Commission } from '@lib/domain';
+import { d, now } from '@lib/shared';
+import { InstrumentPatchEvent, Store } from '@lib/store';
 
-describe('InstrumentPatchEvent', () => {
+describe(InstrumentPatchEvent.name, () => {
   test('should patch a store', () => {
     const timestamp = now();
     const store = new Store();

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

@@ -1,9 +1,13 @@
-import { Asset, Commission, Instrument, InstrumentSelector } from '../domain';
-import { timestamp } from '../shared';
-import { State, StateChangeTracker } from '.';
-import { assetNotSupportedError, instrumentNotSupportedError } from './error';
-import { StoreEvent } from './store-event';
-import { InnerSet } from './store-state';
+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(
@@ -59,18 +63,18 @@ export class InstrumentSubscriptionEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const instrument = state.universe.instrument.get(this.instrument.id);
     if (!instrument) {
-      throw instrumentNotSupportedError(this.instrument);
+      throw new InstrumentNotSupportedError(this.instrument);
     }
 
     if (this.subscribed) {
       const base = state.universe.asset.get(instrument.base.id);
       if (!base) {
-        throw assetNotSupportedError(instrument.base);
+        throw new AssetNotSupportedError(instrument.base);
       }
 
       const quote = state.universe.asset.get(instrument.quote.id);
       if (!quote) {
-        throw assetNotSupportedError(instrument.quote);
+        throw new AssetNotSupportedError(instrument.quote);
       }
 
       state.subscription.instrument.upsert(instrument);

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

@@ -1,9 +1,8 @@
-import { Asset, Commission, Instrument, Order } from '../domain';
-import { d, now } from '../shared';
-import { Store } from '.';
-import { OrderLoadEvent } from './store-order-event';
+import { Asset, Balance, Commission, Instrument, Order } from '@lib/domain';
+import { d, now } from '@lib/shared';
+import { OrderLoadEvent, Store } from '@lib/store';
 
-describe('OrderLoadEvent', () => {
+describe(OrderLoadEvent.name, () => {
   const instrument = new Instrument(
     0,
     new Asset('btc', 'binance', 8),
@@ -15,12 +14,14 @@ describe('OrderLoadEvent', () => {
   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));
 

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

@@ -1,8 +1,14 @@
-import { InstrumentSelector, Order } from '../domain';
-import { decimal, timestamp } from '../shared';
-import { orderInvalidStateError, orderNotFoundError } from './error';
-import { StoreEvent } from './store-event';
-import { InnerSet, State, StateChangeTracker } from './store-state';
+import { InstrumentSelector, Order } from '@lib/domain';
+import { decimal, timestamp } from '@lib/shared';
+import {
+  BalanceNotFoundError,
+  InnerSet,
+  OrderInvalidStateError,
+  OrderNotFoundError,
+  State,
+  StateChangeTracker,
+  StoreEvent
+} from '@lib/store';
 
 /**
  * Patches a store with an existing pending order.
@@ -28,7 +34,7 @@ export class OrderNewEvent implements StoreEvent {
 
   handle(state: State, changes: StateChangeTracker): void {
     if (this.order.state != 'NEW') {
-      throw orderInvalidStateError(this.order.state, ['NEW']);
+      throw new OrderInvalidStateError(this.order.state, ['NEW']);
     }
 
     this.order.createdAt = this.timestamp;
@@ -41,6 +47,27 @@ export class OrderNewEvent implements StoreEvent {
 
     orderByInstrument.upsert(this.order);
 
+    const base = state.balance.get(this.order.instrument.base.id);
+    const quote = state.balance.get(this.order.instrument.quote.id);
+
+    if (!base || !quote) {
+      throw new BalanceNotFoundError(
+        !base ? this.order.instrument.base : this.order.instrument.quote
+      );
+    }
+
+    if (base.tryAddTransientFunding(this.order)) {
+      base.timestamp = this.timestamp;
+
+      changes.commit(base);
+    }
+
+    if (quote.tryAddTransientFunding(this.order)) {
+      quote.timestamp = this.timestamp;
+
+      changes.commit(quote);
+    }
+
     changes.commit(this.order);
   }
 }
@@ -55,14 +82,14 @@ export class OrderPendingEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const order = state.order
       .tryGetOrSet(this.instrument.id, () => {
-        throw orderNotFoundError(this.id);
+        throw new OrderNotFoundError(this.id);
       })
       .tryGetOrSet(this.id, () => {
-        throw orderNotFoundError(this.id);
+        throw new OrderNotFoundError(this.id);
       });
 
     if (order.state != 'NEW') {
-      throw orderInvalidStateError(order.state, ['NEW']);
+      throw new OrderInvalidStateError(order.state, ['NEW']);
     }
 
     order.state = 'PENDING';
@@ -83,14 +110,14 @@ export class OrderFilledEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const order = state.order
       .tryGetOrSet(this.instrument.id, () => {
-        throw orderNotFoundError(this.id);
+        throw new OrderNotFoundError(this.id);
       })
       .tryGetOrSet(this.id, () => {
-        throw orderNotFoundError(this.id);
+        throw new OrderNotFoundError(this.id);
       });
 
     if (order.state != 'PENDING' && order.state != 'CANCELING') {
-      throw orderInvalidStateError(order.state, ['PENDING', 'CANCELING']);
+      throw new OrderInvalidStateError(order.state, ['PENDING', 'CANCELING']);
     }
 
     order.state = 'FILLED';
@@ -112,10 +139,10 @@ export class OrderCancelingEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const order = state.order
       .tryGetOrSet(this.instrument.id, () => {
-        throw orderNotFoundError(this.id);
+        throw new OrderNotFoundError(this.id);
       })
       .tryGetOrSet(this.id, () => {
-        throw orderNotFoundError(this.id);
+        throw new OrderNotFoundError(this.id);
       });
 
     if (order.state == 'CANCELING' || order.state == 'CANCELED') {
@@ -123,7 +150,7 @@ export class OrderCancelingEvent implements StoreEvent {
     }
 
     if (order.state != 'PENDING') {
-      throw orderInvalidStateError(order.state, ['PENDING']);
+      throw new OrderInvalidStateError(order.state, ['PENDING']);
     }
 
     order.state = 'CANCELING';
@@ -143,10 +170,10 @@ export class OrderCanceledEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const order = state.order
       .tryGetOrSet(this.instrument.id, () => {
-        throw orderNotFoundError(this.id);
+        throw new OrderNotFoundError(this.id);
       })
       .tryGetOrSet(this.id, () => {
-        throw orderNotFoundError(this.id);
+        throw new OrderNotFoundError(this.id);
       });
 
     if (order.state == 'CANCELED') {
@@ -154,12 +181,33 @@ export class OrderCanceledEvent implements StoreEvent {
     }
 
     if (order.state != 'CANCELING') {
-      throw orderInvalidStateError(order.state, ['CANCELING']);
+      throw new OrderInvalidStateError(order.state, ['CANCELING']);
     }
 
     order.state = 'CANCELED';
     order.timestamp = this.timestamp;
 
+    const base = state.balance.get(order.instrument.base.id);
+    const quote = state.balance.get(order.instrument.quote.id);
+
+    if (!base || !quote) {
+      throw new BalanceNotFoundError(
+        !base ? order.instrument.base : order.instrument.quote
+      );
+    }
+
+    if (base.tryRemoveTransientFunding(order)) {
+      base.timestamp = this.timestamp;
+
+      changes.commit(base);
+    }
+
+    if (quote.tryRemoveTransientFunding(order)) {
+      quote.timestamp = this.timestamp;
+
+      changes.commit(quote);
+    }
+
     changes.commit(order);
   }
 }
@@ -174,10 +222,10 @@ export class OrderCancelFailedEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const order = state.order
       .tryGetOrSet(this.instrument.id, () => {
-        throw orderNotFoundError(this.id);
+        throw new OrderNotFoundError(this.id);
       })
       .tryGetOrSet(this.id, () => {
-        throw orderNotFoundError(this.id);
+        throw new OrderNotFoundError(this.id);
       });
 
     if (order.state != 'CANCELING') {
@@ -201,19 +249,40 @@ export class OrderRejectedEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const order = state.order
       .tryGetOrSet(this.instrument.id, () => {
-        throw orderNotFoundError(this.id);
+        throw new OrderNotFoundError(this.id);
       })
       .tryGetOrSet(this.id, () => {
-        throw orderNotFoundError(this.id);
+        throw new OrderNotFoundError(this.id);
       });
 
     if (order.state != 'NEW') {
-      throw orderInvalidStateError(order.state, ['NEW']);
+      throw new OrderInvalidStateError(order.state, ['NEW']);
     }
 
     order.state = 'REJECTED';
     order.timestamp = this.timestamp;
 
+    const base = state.balance.get(order.instrument.base.id);
+    const quote = state.balance.get(order.instrument.quote.id);
+
+    if (!base || !quote) {
+      throw new BalanceNotFoundError(
+        !base ? order.instrument.base : order.instrument.quote
+      );
+    }
+
+    if (base.tryRemoveTransientFunding(order)) {
+      base.timestamp = this.timestamp;
+
+      changes.commit(base);
+    }
+
+    if (quote.tryRemoveTransientFunding(order)) {
+      quote.timestamp = this.timestamp;
+
+      changes.commit(quote);
+    }
+
     changes.commit(order);
   }
 }

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

@@ -1,9 +1,8 @@
-import { Asset, Commission, Instrument, Liquidity } from '../domain';
-import { d, now } from '../shared';
-import { OrderbookPatchEvent } from '.';
-import { Store } from './store';
+import { Asset, Commission, Instrument, Liquidity } from '@lib/domain';
+import { d, now } from '@lib/shared';
+import { OrderbookPatchEvent, Store } from '@lib/store';
 
-describe('OrderbookPatchEvent', () => {
+describe(OrderbookPatchEvent.name, () => {
   const instrument = new Instrument(
     0,
     new Asset('btc', 'binance', 8),

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

@@ -1,8 +1,12 @@
-import { InstrumentSelector, Liquidity, Orderbook } from '../domain';
-import { timestamp } from '../shared';
-import { instrumentNotSupportedError, liquidationError } from './error';
-import { StoreEvent } from './store-event';
-import { State, StateChangeTracker } from './store-state';
+import { InstrumentSelector, Liquidity, Orderbook } from '@lib/domain';
+import { timestamp } from '@lib/shared';
+import {
+  InstrumentNotSupportedError,
+  LiquidationError,
+  State,
+  StateChangeTracker,
+  StoreEvent
+} from '@lib/store';
 
 export class OrderbookPatchEvent implements StoreEvent {
   constructor(
@@ -15,7 +19,7 @@ export class OrderbookPatchEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const instrument = state.universe.instrument.get(this.instrument.id);
     if (!instrument) {
-      throw instrumentNotSupportedError(this.instrument);
+      throw new InstrumentNotSupportedError(this.instrument);
     }
 
     const orderbook = state.orderbook.tryGetOrSet(
@@ -47,7 +51,7 @@ export class OrderbookPatchEvent implements StoreEvent {
       }
 
       if (quote.total.lessThan(0)) {
-        throw liquidationError();
+        throw new LiquidationError();
       }
     }