@quantform/core 0.3.210 → 0.3.215

package/src/session/session.ts

@@ -16,7 +16,8 @@ import {
   InstrumentSelector,
   Order,
   Position,
-  Orderbook
+  Orderbook,
+  OrderState
 } from '../domain';
 import { Store } from '../store';
 import { from, Observable, Subscription } from 'rxjs';
@@ -236,30 +237,57 @@ export class Session {
     );
   }
 
-  orders(selector?: InstrumentSelector): Observable<Order[]> {
+  private ordersOf(
+    orders: Order[],
+    states: OrderState[],
+    selector?: InstrumentSelector
+  ): Observable<Order[]> {
     this.subscribe([selector]);
 
-    const snapshot = this.store.snapshot;
-
     return this.store.changes$.pipe(
       filter(
         it =>
           it instanceof Order &&
-          (!selector || it.instrument.toString() == selector.toString())
+          (!selector || it.instrument.toString() == selector.toString()) &&
+          (states.indexOf(it.state) >= 0 || states.length == 0)
       ),
       map(() =>
-        Object.values(snapshot.order.pending).filter(
-          it => !selector || it.instrument.toString() == selector.toString()
-        )
+        Object.values(orders)
+          .filter(it => !selector || it.instrument.toString() == selector.toString())
+          .sort((lhs, rhs) => rhs.createdAt - lhs.createdAt)
       ),
       startWith(
-        Object.values(snapshot.order.pending).filter(
-          it => !selector || it.instrument.toString() == selector.toString()
-        )
+        Object.values(orders)
+          .filter(it => !selector || it.instrument.toString() == selector.toString())
+          .sort((lhs, rhs) => rhs.createdAt - lhs.createdAt)
       )
     );
   }
 
+  pending(selector?: InstrumentSelector): Observable<Order[]> {
+    return this.ordersOf(
+      Object.values(this.store.snapshot.order.pending),
+      ['PENDING', 'NEW'],
+      selector
+    );
+  }
+
+  filled(selector?: InstrumentSelector): Observable<Order[]> {
+    return this.ordersOf(
+      Object.values(this.store.snapshot.order.filled),
+      ['FILLED'],
+      selector
+    );
+  }
+
+  canceled(selector?: InstrumentSelector): Observable<Order[]> {
+    return this.ordersOf(
+      Object.values(this.store.snapshot.order.canceled),
+      ['CANCELING', 'CANCELED'],
+      selector
+    );
+  }
+
   balance(selector?: AssetSelector): Observable<Balance> {
     return this.store.changes$.pipe(
       startWith(selector ? this.store.snapshot.balance[selector.toString()] : null),

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

@@ -72,6 +72,7 @@ export function BalanceTransactEventHandler(event: BalanceTransactEvent, state:
     state.balance[asset.toString()] = balance;
   }
 
+  balance.timestamp = event.timestamp;
   balance.transact(event.amount);
 
   state.timestamp = event.timestamp;
@@ -103,6 +104,7 @@ export function BalanceFreezEventHandler(event: BalanceFreezEvent, state: State)
     throw new Error('invalid balance');
   }
 
+  balance.timestamp = event.timestamp;
   balance.freez(event.amount);
 
   state.timestamp = event.timestamp;
@@ -134,6 +136,7 @@ export function BalanceUnfreezEventHandler(event: BalanceUnfreezEvent, state: St
     throw new Error('invalid balance');
   }
 
+  balance.timestamp = event.timestamp;
   balance.unfreez(event.amount);
 
   state.timestamp = event.timestamp;

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

@@ -15,16 +15,27 @@ export function OrderLoadEventHandler(event: OrderLoadEvent, state: State) {
   const instrumentKey = event.order.instrument.toString();
 
   if (!(instrumentKey in state.subscription.instrument)) {
-    throw new Error(`Trying to order for unsubscribed instrument: ${instrumentKey}`);
-  }
-
-  if (event.order.state != 'PENDING') {
-    throw new Error(`Order is not pending`);
+    throw new Error(`Trying to load order for unsubscribed instrument: ${instrumentKey}`);
   }
 
   event.order.timestamp = event.timestamp;
 
-  state.order.pending[event.order.id] = event.order;
+  switch (event.order.state) {
+    case 'NEW':
+    case 'PENDING':
+      state.order.pending[event.order.id] = event.order;
+      break;
+    case 'FILLED':
+      state.order.filled[event.order.id] = event.order;
+      break;
+    case 'CANCELING':
+    case 'CANCELED':
+      state.order.canceled[event.order.id] = event.order;
+      break;
+    case 'REJECTED':
+      state.order.rejected[event.order.id] = event.order;
+      break;
+  }
 
   return event.order;
 }
@@ -80,8 +91,8 @@ export function OrderPendingEventHandler(event: OrderPendingEvent, state: State)
 }
 
 @event
-export class OrderCompletedEvent implements StoreEvent {
-  type = 'order-completed';
+export class OrderFilledEvent implements StoreEvent {
+  type = 'order-filled';
 
   constructor(
     readonly id: string,
@@ -90,7 +101,7 @@ export class OrderCompletedEvent implements StoreEvent {
   ) {}
 }
 
-export function OrderCompletedEventHandler(event: OrderCompletedEvent, state: State) {
+export function OrderFilledEventHandler(event: OrderFilledEvent, state: State) {
   if (!(event.id in state.order.pending)) {
     throw new Error(`Trying to patch unknown order: ${event.id}`);
   }
@@ -101,14 +112,14 @@ export function OrderCompletedEventHandler(event: OrderCompletedEvent, state: St
     throw new Error('Order is not pending');
   }
 
-  order.state = 'COMPLETED';
+  order.state = 'FILLED';
   order.timestamp = event.timestamp;
   order.quantityExecuted = order.quantity;
   order.averageExecutionRate = event.averageExecutionRate;
 
   delete state.order.pending[event.id];
 
-  state.order.completed[event.id] = order;
+  state.order.filled[event.id] = order;
 
   return order;
 }

package/src/store/store.state.ts

@@ -35,12 +35,12 @@ export class State {
 
   order: {
     pending: Record<string, Order>;
-    completed: Record<string, Order>;
+    filled: Record<string, Order>;
     canceled: Record<string, Order>;
     rejected: Record<string, Order>;
   } = {
     pending: {},
-    completed: {},
+    filled: {},
     canceled: {},
     rejected: {}
   };

package/src/store/store.ts

@@ -26,8 +26,8 @@ import {
   OrderCancelFailedEventHandler,
   OrderCancelingEvent,
   OrderCancelingEventHandler,
-  OrderCompletedEvent,
-  OrderCompletedEventHandler,
+  OrderFilledEvent,
+  OrderFilledEventHandler,
   OrderLoadEvent,
   OrderLoadEventHandler,
   OrderNewEvent,
@@ -152,11 +152,11 @@ export class Store extends Topic<StoreEvent, any> {
   }
 
   /**
-   * @see OrderCompletedEventHandler
+   * @see OrderFilledEventHandler
    */
-  @handler(OrderCompletedEvent)
-  onOrderCompleted(event: OrderCompletedEvent) {
-    return OrderCompletedEventHandler(event, this.snapshot);
+  @handler(OrderFilledEvent)
+  onOrderFilled(event: OrderFilledEvent) {
+    return OrderFilledEventHandler(event, this.snapshot);
   }
 
   /**