@quantform/core 0.5.23 → 0.6.4

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);
+  });
+});

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

@@ -1,12 +1,17 @@
 import { InstrumentSelector, Order } from '../domain';
 import { decimal, timestamp } from '../shared';
-import { StoreEvent } from './store.event';
+import { orderInvalidStateError, orderNotFoundError } from './error';
+import { StoreEvent } from './store-event';
 import { InnerSet, State, StateChangeTracker } from './store-state';
 
+/**
+ * Patches a store with an existing pending order.
+ * No store changing events are propagated.
+ */
 export class OrderLoadEvent implements StoreEvent {
   constructor(readonly order: Order, readonly timestamp: timestamp) {}
 
-  handle(state: State, changes: StateChangeTracker): void {
+  handle(state: State): void {
     this.order.timestamp = this.timestamp;
 
     const orderByInstrument = state.order.tryGetOrSet(
@@ -23,7 +28,7 @@ export class OrderNewEvent implements StoreEvent {
 
   handle(state: State, changes: StateChangeTracker): void {
     if (this.order.state != 'NEW') {
-      throw new Error(`Order is not new`);
+      throw orderInvalidStateError(this.order.state, ['NEW']);
     }
 
     this.order.createdAt = this.timestamp;
@@ -50,14 +55,14 @@ export class OrderPendingEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const order = state.order
       .tryGetOrSet(this.instrument.id, () => {
-        throw new Error(`Trying to patch unknown order: ${this.id}`);
+        throw orderNotFoundError(this.id);
       })
       .tryGetOrSet(this.id, () => {
-        throw new Error(`Trying to patch unknown order: ${this.id}`);
+        throw orderNotFoundError(this.id);
       });
 
     if (order.state != 'NEW') {
-      throw new Error(`Order is not NEW: ${order.state}`);
+      throw orderInvalidStateError(order.state, ['NEW']);
     }
 
     order.state = 'PENDING';
@@ -78,14 +83,14 @@ export class OrderFilledEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const order = state.order
       .tryGetOrSet(this.instrument.id, () => {
-        throw new Error(`Trying to patch unknown order: ${this.id}`);
+        throw orderNotFoundError(this.id);
       })
       .tryGetOrSet(this.id, () => {
-        throw new Error(`Trying to patch unknown order: ${this.id}`);
+        throw orderNotFoundError(this.id);
       });
 
     if (order.state != 'PENDING' && order.state != 'CANCELING') {
-      throw new Error(`Order is not PENDING or CANCELING: ${order.state}`);
+      throw orderInvalidStateError(order.state, ['PENDING', 'CANCELING']);
     }
 
     order.state = 'FILLED';
@@ -107,10 +112,10 @@ export class OrderCancelingEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const order = state.order
       .tryGetOrSet(this.instrument.id, () => {
-        throw new Error(`Trying to patch unknown order: ${this.id}`);
+        throw orderNotFoundError(this.id);
       })
       .tryGetOrSet(this.id, () => {
-        throw new Error(`Trying to patch unknown order: ${this.id}`);
+        throw orderNotFoundError(this.id);
       });
 
     if (order.state == 'CANCELING' || order.state == 'CANCELED') {
@@ -118,7 +123,7 @@ export class OrderCancelingEvent implements StoreEvent {
     }
 
     if (order.state != 'PENDING') {
-      throw new Error(`Order is not PENDING: ${order.state}`);
+      throw orderInvalidStateError(order.state, ['PENDING']);
     }
 
     order.state = 'CANCELING';
@@ -138,10 +143,10 @@ export class OrderCanceledEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const order = state.order
       .tryGetOrSet(this.instrument.id, () => {
-        throw new Error(`Trying to patch unknown order: ${this.id}`);
+        throw orderNotFoundError(this.id);
       })
       .tryGetOrSet(this.id, () => {
-        throw new Error(`Trying to patch unknown order: ${this.id}`);
+        throw orderNotFoundError(this.id);
       });
 
     if (order.state == 'CANCELED') {
@@ -149,7 +154,7 @@ export class OrderCanceledEvent implements StoreEvent {
     }
 
     if (order.state != 'CANCELING') {
-      throw new Error(`Order is not CANCELING: ${order.state}`);
+      throw orderInvalidStateError(order.state, ['CANCELING']);
     }
 
     order.state = 'CANCELED';
@@ -169,10 +174,10 @@ export class OrderCancelFailedEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const order = state.order
       .tryGetOrSet(this.instrument.id, () => {
-        throw new Error(`Trying to patch unknown order: ${this.id}`);
+        throw orderNotFoundError(this.id);
       })
       .tryGetOrSet(this.id, () => {
-        throw new Error(`Trying to patch unknown order: ${this.id}`);
+        throw orderNotFoundError(this.id);
       });
 
     if (order.state != 'CANCELING') {
@@ -196,14 +201,14 @@ export class OrderRejectedEvent implements StoreEvent {
   handle(state: State, changes: StateChangeTracker): void {
     const order = state.order
       .tryGetOrSet(this.instrument.id, () => {
-        throw new Error(`Trying to patch unknown order: ${this.id}`);
+        throw orderNotFoundError(this.id);
       })
       .tryGetOrSet(this.id, () => {
-        throw new Error(`Trying to patch unknown order: ${this.id}`);
+        throw orderNotFoundError(this.id);
       });
 
     if (order.state != 'NEW') {
-      throw new Error(`Order is not NEW: ${order.state}`);
+      throw orderInvalidStateError(order.state, ['NEW']);
     }
 
     order.state = 'REJECTED';

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

@@ -1,15 +1,17 @@
-import { Store } from '..';
-import { Asset, Instrument, Liquidity } from '../domain';
+import { Asset, Commission, Instrument, Liquidity } from '../domain';
 import { d, now } from '../shared';
 import { OrderbookPatchEvent } from '.';
-
-const instrument = new Instrument(
-  new Asset('btc', 'binance', 8),
-  new Asset('usdt', 'binance', 2),
-  'binance:btc-usdt'
-);
+import { Store } from './store';
 
 describe('OrderbookPatchEvent', () => {
+  const instrument = new Instrument(
+    0,
+    new Asset('btc', 'binance', 8),
+    new Asset('usdt', 'binance', 2),
+    'binance:btc-usdt',
+    Commission.Zero
+  );
+
   let store: Store;
 
   beforeEach(() => {
@@ -26,7 +28,7 @@ describe('OrderbookPatchEvent', () => {
 
     store.dispatch(new OrderbookPatchEvent(instrument, ask, bid, timestamp));
 
-    const orderbook = store.snapshot.orderbook.get(instrument.id);
+    const orderbook = store.snapshot.orderbook.get(instrument.id) ?? fail();
 
     expect(orderbook.timestamp).toEqual(timestamp);
     expect(orderbook.instrument.id).toEqual(orderbook.instrument.id);

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

@@ -1,6 +1,7 @@
 import { InstrumentSelector, Liquidity, Orderbook } from '../domain';
 import { timestamp } from '../shared';
-import { StoreEvent } from './store.event';
+import { instrumentNotSupportedError, liquidationError } from './error';
+import { StoreEvent } from './store-event';
 import { State, StateChangeTracker } from './store-state';
 
 export class OrderbookPatchEvent implements StoreEvent {
@@ -12,13 +13,14 @@ export class OrderbookPatchEvent implements StoreEvent {
   ) {}
 
   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 instrument = state.universe.instrument.get(this.instrument.id);
+    if (!instrument) {
+      throw instrumentNotSupportedError(this.instrument);
     }
 
     const orderbook = state.orderbook.tryGetOrSet(
       this.instrument.id,
-      () => new Orderbook(state.universe.instrument.get(this.instrument.id))
+      () => new Orderbook(0, instrument, this.ask, this.bid)
     );
 
     state.timestamp = this.timestamp;
@@ -45,7 +47,7 @@ export class OrderbookPatchEvent implements StoreEvent {
       }
 
       if (quote.total.lessThan(0)) {
-        throw new Error('You have been liquidated.');
+        throw liquidationError();
       }
     }
 

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

@@ -1,25 +1,27 @@
 import { Instrument, Position, PositionMode } from '../domain';
 import { decimal, timestamp } from '../shared';
-import { StoreEvent } from './store.event';
+import { balanceNotFoundError, instrumentNotSubscribedError } from './error';
+import { StoreEvent } from './store-event';
 import { State, StateChangeTracker } from './store-state';
 
 export class PositionLoadEvent implements StoreEvent {
   constructor(readonly position: Position, readonly timestamp: timestamp) {}
 
-  handle(state: State, changes: StateChangeTracker): void {
+  handle(state: State): void {
     if (!state.subscription.instrument.get(this.position.instrument.id)) {
-      throw new Error(
-        `Trying to patch unsubscribed instrument: ${this.position.instrument.id}`
-      );
+      throw instrumentNotSubscribedError(this.position.instrument);
     }
 
     this.position.timestamp = this.timestamp;
 
     const balance = state.balance.get(this.position.instrument.quote.id);
-    const orderbook = state.orderbook.get(this.position.instrument.id);
+    if (!balance) {
+      throw balanceNotFoundError(this.position.instrument.quote);
+    }
 
     balance.position[this.position.id] = this.position;
 
+    const orderbook = state.orderbook.get(this.position.instrument.id);
     if (orderbook) {
       const rate = this.position.size.greaterThanOrEqualTo(0)
         ? orderbook.bids.rate
@@ -46,10 +48,14 @@ export class PositionPatchEvent implements StoreEvent {
   // eslint-disable-next-line complexity
   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}`);
+      throw instrumentNotSubscribedError(this.instrument);
     }
 
     const balance = state.balance.get(this.instrument.quote.id);
+    if (!balance) {
+      throw balanceNotFoundError(this.instrument.quote);
+    }
+
     const orderbook = state.orderbook.get(this.instrument.id);
 
     let position = balance.position[this.id];
@@ -83,6 +89,7 @@ export class PositionPatchEvent implements StoreEvent {
 
     if (!position) {
       position = new Position(
+        this.timestamp,
         this.id,
         this.instrument,
         this.mode,

package/src/store/store-state.ts

@@ -12,8 +12,8 @@ import {
 import { Set, timestamp } from '../shared';
 
 export interface StateChangeTracker {
-  commit(component: Component);
-  commitPendingChanges();
+  commit(component: Component): void;
+  commitPendingChanges(): void;
 }
 
 export class InnerSet<T extends { id: string }> extends Set<T> {
@@ -23,7 +23,7 @@ export class InnerSet<T extends { id: string }> extends Set<T> {
 }
 
 export class State {
-  timestamp: timestamp;
+  timestamp: timestamp = 0;
 
   universe: {
     asset: Set<Asset>;

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

@@ -1,12 +1,14 @@
-import { Store } from '..';
-import { Asset, Instrument } from '../domain';
+import { Asset, Commission, Instrument } from '../domain';
 import { d, now } from '../shared';
 import { TradePatchEvent } from '.';
+import { Store } from './store';
 
 const instrument = new Instrument(
+  0,
   new Asset('btc', 'binance', 8),
   new Asset('usdt', 'binance', 2),
-  'binance:btc-usdt'
+  'binance:btc-usdt',
+  Commission.Zero
 );
 
 describe('TradePatchEvent', () => {
@@ -19,7 +21,7 @@ describe('TradePatchEvent', () => {
 
     store.dispatch(new TradePatchEvent(instrument, d(1000), d(0.1), timestamp));
 
-    const trade = store.snapshot.trade.get(instrument.id);
+    const trade = store.snapshot.trade.get(instrument.id) ?? fail();
 
     expect(trade.timestamp).toEqual(timestamp);
     expect(trade.instrument.id).toEqual(trade.instrument.id);
@@ -37,7 +39,7 @@ describe('TradePatchEvent', () => {
 
     store.dispatch(new TradePatchEvent(instrument, d(1000), d(0.1), timestamp));
 
-    const trade = store.snapshot.trade.get(instrument.id);
+    const trade = store.snapshot.trade.get(instrument.id) ?? fail();
 
     store.dispatch(new TradePatchEvent(instrument, d(2000), d(0.2), timestamp));
 

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

@@ -1,6 +1,7 @@
 import { InstrumentSelector, Trade } from '../domain';
-import { decimal, timestamp } from '../shared';
-import { StoreEvent } from './store.event';
+import { d, decimal, timestamp } from '../shared';
+import { instrumentNotSubscribedError, instrumentNotSupportedError } from './error';
+import { StoreEvent } from './store-event';
 import { State, StateChangeTracker } from './store-state';
 
 /**
@@ -17,12 +18,17 @@ export class TradePatchEvent implements StoreEvent {
 
   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}`);
+      throw instrumentNotSubscribedError(this.instrument);
+    }
+
+    const instrument = state.universe.instrument.get(this.instrument.id);
+    if (!instrument) {
+      throw instrumentNotSupportedError(this.instrument);
     }
 
     const trade = state.trade.tryGetOrSet(
       this.instrument.id,
-      () => new Trade(state.universe.instrument.get(this.instrument.id))
+      () => new Trade(0, instrument, d.Zero, d.Zero)
     );
 
     state.timestamp = this.timestamp;

package/src/store/store.spec.ts

@@ -1,9 +1,9 @@
 import { withLatestFrom } from 'rxjs';
 
-import { Asset, balance, Instrument, Order, order } from '../domain';
+import { Asset, balance, Commission, Instrument, Order, order } from '../domain';
 import { d, now } from '../shared';
 import { Store } from './store';
-import { BalanceTransactEvent } from './store-balance.event';
+import { BalanceTransactEvent } from './store-balance-event';
 import {
   OrderCanceledEvent,
   OrderCancelingEvent,
@@ -11,12 +11,14 @@ import {
   OrderLoadEvent,
   OrderNewEvent,
   OrderPendingEvent
-} from './store-order.event';
+} from './store-order-event';
 
 const instrument = new Instrument(
+  0,
   new Asset('abc', 'xyz', 4),
   new Asset('def', 'xyz', 4),
-  'abc-def'
+  'abc-def',
+  Commission.Zero
 );
 
 describe('Store', () => {
@@ -35,7 +37,7 @@ describe('Store', () => {
       }
     });
 
-    store.dispatch(new OrderLoadEvent(Order.market(instrument, d(10)), now()));
+    store.dispatch(new OrderLoadEvent(new Order(0, '1', instrument, d(10), 0), now()));
 
     expect(hasUpdatedOrder).toBe(false);
   });
@@ -49,7 +51,7 @@ describe('Store', () => {
       }
     });
 
-    store.dispatch(new OrderNewEvent(Order.market(instrument, d(10)), now()));
+    store.dispatch(new OrderNewEvent(new Order(0, '1', instrument, d(10), 0), now()));
 
     expect(hasUpdatedOrder).toBe(true);
   });
@@ -63,7 +65,7 @@ describe('Store', () => {
       }
     });
 
-    const buyOrder = Order.market(instrument, d(10));
+    const buyOrder = new Order(0, '1', instrument, d(10), 0);
 
     store.dispatch(new OrderNewEvent(buyOrder, now()));
     store.dispatch(new OrderPendingEvent(buyOrder.id, instrument, now()));
@@ -81,7 +83,7 @@ describe('Store', () => {
       }
     });
 
-    const buyOrder = Order.market(instrument, d(10));
+    const buyOrder = new Order(0, '1', instrument, d(10), 0);
 
     store.dispatch(new OrderNewEvent(buyOrder, now()));
     store.dispatch(new OrderPendingEvent(buyOrder.id, instrument, now()));
@@ -101,7 +103,7 @@ describe('Store', () => {
       }
     });
 
-    const buyOrder = Order.market(instrument, d(10));
+    const buyOrder = new Order(0, '1', instrument, d(10), 0);
 
     store.dispatch(new OrderNewEvent(buyOrder, now()));
     store.dispatch(new OrderPendingEvent(buyOrder.id, instrument, now()));
@@ -130,7 +132,7 @@ describe('Store', () => {
         }
       });
 
-    const buyOrder = Order.market(instrument, d(10));
+    const buyOrder = new Order(0, '1', instrument, d(10), 0);
 
     store.dispatch(
       new OrderNewEvent(buyOrder, now()),
@@ -169,7 +171,7 @@ describe('Store', () => {
       }
     });
 
-    const buyOrder = Order.market(instrument, d(10));
+    const buyOrder = new Order(0, '1', instrument, d(10), 0);
 
     store.dispatch(
       new OrderNewEvent(buyOrder, now()),