@quantform/core 0.5.15 → 0.6.4

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

@@ -1,8 +1,8 @@
 import { Asset, Commission } from '../domain';
-import { now } from '../shared';
+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', () => {
@@ -15,15 +15,15 @@ describe('BalancePatchEvent', () => {
     store.changes$.subscribe(it => (component = it));
 
     store.dispatch(
-      new InstrumentPatchEvent(timestamp, base, quote, new Commission(0, 0), '')
+      new InstrumentPatchEvent(timestamp, base, quote, new Commission(d.Zero, d.Zero), '')
     );
-    store.dispatch(new BalancePatchEvent(base, 100, 0, timestamp));
+    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(100);
-    expect(balance.locked).toEqual(0);
+    expect(balance.free).toEqual(d(100));
+    expect(balance.locked).toEqual(d.Zero);
     expect(balance.timestamp).toEqual(timestamp);
     expect(store.snapshot.timestamp).toEqual(timestamp);
   });

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

@@ -1,6 +1,12 @@
 import { AssetSelector, Balance, InstrumentSelector } from '../domain';
-import { timestamp } from '../shared';
-import { StoreEvent } from './store.event';
+import { decimal, timestamp } from '../shared';
+import {
+  assetNotSupportedError,
+  balanceNotFoundError,
+  instrumentNotSubscribedError,
+  orderNotFoundError
+} from './error';
+import { StoreEvent } from './store-event';
 import { State, StateChangeTracker } from './store-state';
 
 /**
@@ -9,19 +15,22 @@ import { State, StateChangeTracker } from './store-state';
 export class BalancePatchEvent implements StoreEvent {
   constructor(
     readonly asset: AssetSelector,
-    readonly free: number,
-    readonly freezed: number,
+    readonly free: decimal,
+    readonly freezed: decimal,
     readonly timestamp: timestamp
   ) {}
 
   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,22 +40,24 @@ export class BalancePatchEvent implements StoreEvent {
     changes.commit(balance);
   }
 }
+
 /**
  *
  */
 export class BalanceTransactEvent implements StoreEvent {
   constructor(
     readonly asset: AssetSelector,
-    readonly amount: number,
+    readonly amount: decimal,
     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);
+    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 > 0) {
+    if (balanceToLock.base?.greaterThan(0)) {
       base.timestamp = this.timestamp;
       base.lock(this.orderId, balanceToLock.base);
 
       changes.commit(base);
     }
 
-    if (balanceToLock.quote > 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 { now } from '../shared';
-import { InstrumentPatchEvent } from './store-instrument.event';
+import { d, now } from '../shared';
+import { Store } from './store';
+import { InstrumentPatchEvent } from './store-instrument-event';
 
 describe('InstrumentPatchEvent', () => {
   test('should patch a store', () => {
@@ -11,14 +11,15 @@ describe('InstrumentPatchEvent', () => {
     const quote = new Asset('usd', 'cex', 2);
 
     store.dispatch(
-      new InstrumentPatchEvent(timestamp, base, quote, new Commission(0, 0), '')
+      new InstrumentPatchEvent(timestamp, base, quote, new Commission(d.Zero, d.Zero), '')
     );
 
     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,8 +1,9 @@
-import { Asset, Commission, InstrumentSelector, Instrument } from '../domain';
+import { Asset, Commission, Instrument, InstrumentSelector } from '../domain';
 import { timestamp } from '../shared';
-import { State, StateChangeTracker } from '../store';
+import { State, StateChangeTracker } from '.';
+import { assetNotSupportedError, instrumentNotSupportedError } from './error';
+import { StoreEvent } from './store-event';
 import { InnerSet } from './store-state';
-import { StoreEvent } from './store.event';
 
 export class InstrumentPatchEvent implements StoreEvent {
   constructor(
@@ -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 { timestamp } from '../shared';
-import { StoreEvent } from './store.event';
+import { decimal, timestamp } from '../shared';
+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';
@@ -71,21 +76,21 @@ export class OrderFilledEvent implements StoreEvent {
   constructor(
     readonly id: string,
     readonly instrument: InstrumentSelector,
-    readonly averageExecutionRate: number,
+    readonly averageExecutionRate: decimal,
     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}`);
+        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

@@ -0,0 +1,39 @@
+import { Asset, Commission, Instrument, Liquidity } from '../domain';
+import { d, now } from '../shared';
+import { OrderbookPatchEvent } from '.';
+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(() => {
+    store = new Store();
+    store.snapshot.universe.instrument.upsert(instrument);
+    store.snapshot.subscription.instrument.upsert(instrument);
+  });
+
+  test('should set a best bid and ask', () => {
+    const timestamp = now();
+
+    const ask: Liquidity = { rate: d(2), quantity: d(2), next: undefined };
+    const bid: Liquidity = { rate: d(1), quantity: d(1), next: undefined };
+
+    store.dispatch(new OrderbookPatchEvent(instrument, ask, bid, timestamp));
+
+    const orderbook = store.snapshot.orderbook.get(instrument.id) ?? fail();
+
+    expect(orderbook.timestamp).toEqual(timestamp);
+    expect(orderbook.instrument.id).toEqual(orderbook.instrument.id);
+    expect(orderbook.asks).toEqual(ask);
+    expect(orderbook.bids).toEqual(bid);
+    expect(store.snapshot.timestamp).toEqual(timestamp);
+  });
+});

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

@@ -0,0 +1,56 @@
+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';
+
+export class OrderbookPatchEvent implements StoreEvent {
+  constructor(
+    readonly instrument: InstrumentSelector,
+    readonly ask: Liquidity,
+    readonly bid: Liquidity,
+    readonly timestamp: timestamp
+  ) {}
+
+  handle(state: State, changes: StateChangeTracker): void {
+    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(0, instrument, this.ask, this.bid)
+    );
+
+    state.timestamp = this.timestamp;
+
+    orderbook.timestamp = this.timestamp;
+    orderbook.asks = this.ask;
+    orderbook.bids = this.bid;
+
+    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.greaterThanOrEqualTo(0)
+          ? orderbook.bids.rate
+          : orderbook.asks.rate;
+
+        if (rate) {
+          position.calculateEstimatedUnrealizedPnL(rate);
+        }
+      }
+
+      if (quote.total.lessThan(0)) {
+        throw liquidationError();
+      }
+    }
+
+    changes.commit(orderbook);
+  }
+}

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

@@ -1,30 +1,35 @@
 import { Instrument, Position, PositionMode } from '../domain';
-import { timestamp } from '../shared';
-import { StoreEvent } from './store.event';
+import { decimal, timestamp } from '../shared';
+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 >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
+      const rate = this.position.size.greaterThanOrEqualTo(0)
+        ? orderbook.bids.rate
+        : orderbook.asks.rate;
 
-      this.position.calculateEstimatedUnrealizedPnL(rate);
+      if (rate) {
+        this.position.calculateEstimatedUnrealizedPnL(rate);
+      }
     }
   }
 }
@@ -33,35 +38,44 @@ export class PositionPatchEvent implements StoreEvent {
   constructor(
     readonly id: string,
     readonly instrument: Instrument,
-    readonly rate: number,
-    readonly size: number,
+    readonly rate: decimal,
+    readonly size: decimal,
     readonly leverage: number,
     readonly mode: PositionMode,
     readonly timestamp: timestamp
   ) {}
 
+  // 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];
 
-    if (this.size == 0) {
+    if (this.size.equals(0)) {
       if (position) {
-        position.averageExecutionRate = this.instrument.quote.fixed(this.rate);
-        position.size = this.instrument.base.fixed(this.size);
+        position.averageExecutionRate = this.instrument.quote.floor(this.rate);
+        position.size = this.instrument.base.floor(this.size);
         position.leverage = this.leverage;
 
         delete balance.position[this.id];
 
         if (orderbook) {
-          const rate = position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
+          const rate = position.size.greaterThanOrEqualTo(0)
+            ? orderbook.bids.rate
+            : orderbook.asks.rate;
 
-          position.calculateEstimatedUnrealizedPnL(rate);
+          if (rate) {
+            position.calculateEstimatedUnrealizedPnL(rate);
+          }
         }
 
         changes.commit(position);
@@ -69,12 +83,13 @@ export class PositionPatchEvent implements StoreEvent {
       }
     }
 
-    const size = (position.size = this.instrument.base.fixed(this.size));
+    const size = (position.size = this.instrument.base.floor(this.size));
     const averageExecutionRate = (position.averageExecutionRate =
-      this.instrument.quote.fixed(this.rate));
+      this.instrument.quote.floor(this.rate));
 
     if (!position) {
       position = new Position(
+        this.timestamp,
         this.id,
         this.instrument,
         this.mode,
@@ -91,9 +106,13 @@ export class PositionPatchEvent implements StoreEvent {
     }
 
     if (orderbook) {
-      const rate = position.size >= 0 ? orderbook.bestBidRate : orderbook.bestAskRate;
+      const rate = position.size.greaterThanOrEqualTo(0)
+        ? orderbook.bids.rate
+        : orderbook.asks.rate;
 
-      position.calculateEstimatedUnrealizedPnL(rate);
+      if (rate) {
+        position.calculateEstimatedUnrealizedPnL(rate);
+      }
     }
 
     changes.commit(position);