Add risk engine check for GTD order expire time

Author: cjdsellers

RELEASES.md

@@ -7,6 +7,7 @@ This release adds support for Python 3.13 (*not* yet compatible with free-thread
 ### Enhancements
 - Added `allow_past` boolean flag for `Clock.set_timer(...)` to control behavior with start times in the past (default `True` to allow start times in the past)
 - Added `allow_past` boolean flag for `Clock.set_time_alert(...)` to control behavior with alert times in the past (default `True` to fire immediate alert)
+- Added risk engine check for GTD order expire time, which will deny if expire time is already in the past
 - Added instrument updating for exchange and matching engine
 - Added additional price and quantity precision validations for matching engine
 - Added log file rotation with additional config options `max_file_size` and `max_backup_count` (#2468), thanks @xingyanan and @twitu

crates/adapters/tardis/src/python/mod.rs

@@ -21,9 +21,9 @@ pub mod enums;
 pub mod http;
 pub mod machine;
 
-use nautilus_core::python::to_pyvalue_err;
 use std::str::FromStr;
 
+use nautilus_core::python::to_pyvalue_err;
 use pyo3::prelude::*;
 use ustr::Ustr;
 

crates/risk/src/engine/mod.rs

@@ -29,7 +29,7 @@ use nautilus_core::UUID4;
 use nautilus_execution::messages::{ModifyOrder, SubmitOrder, SubmitOrderList, TradingCommand};
 use nautilus_model::{
     accounts::{Account, AccountAny},
-    enums::{InstrumentClass, OrderSide, OrderStatus, TradingState},
+    enums::{InstrumentClass, OrderSide, OrderStatus, TimeInForce, TradingState},
     events::{OrderDenied, OrderEventAny, OrderModifyRejected},
     identifiers::InstrumentId,
     instruments::{Instrument, InstrumentAny},
@@ -508,6 +508,18 @@ impl RiskEngine {
         ////////////////////////////////////////////////////////////////////////////////
         // VALIDATION CHECKS
         ////////////////////////////////////////////////////////////////////////////////
+        if order.time_in_force() == TimeInForce::Gtd {
+            // SAFETY: GTD guarantees an expire time
+            let expire_time = order.expire_time().unwrap();
+            if expire_time <= self.clock.borrow().timestamp_ns() {
+                self.deny_order(
+                    order,
+                    &format!("GTD {} already past", expire_time.to_rfc3339()),
+                );
+                return false; // Denied
+            }
+        }
+
         if !self.check_order_price(instrument.clone(), order.clone())
             || !self.check_order_quantity(instrument, order)
         {
@@ -1049,7 +1061,7 @@ mod tests {
 
     use nautilus_common::{
         cache::Cache,
-        clock::TestClock,
+        clock::{Clock, TestClock},
         msgbus::{
             self,
             handler::ShareableMessageHandler,
@@ -1069,7 +1081,7 @@ mod tests {
             stubs::{cash_account, margin_account},
         },
         data::{QuoteTick, stubs::quote_audusd},
-        enums::{AccountType, LiquiditySide, OrderSide, OrderType, TradingState},
+        enums::{AccountType, LiquiditySide, OrderSide, OrderType, TimeInForce, TradingState},
         events::{
             AccountState, OrderAccepted, OrderDenied, OrderEventAny, OrderEventType, OrderFilled,
             OrderSubmitted, account::stubs::cash_account_state_million_usd,
@@ -4363,4 +4375,83 @@ mod tests {
 
     #[rstest]
     fn test_partial_fill_and_full_fill_account_balance_correct() {}
+
+    #[rstest]
+    fn test_submit_order_with_gtd_expire_time_already_passed(
+        clock: TestClock,
+        strategy_id_ema_cross: StrategyId,
+        client_id_binance: ClientId,
+        trader_id: TraderId,
+        client_order_id: ClientOrderId,
+        instrument_xbtusd_bitmex: InstrumentAny,
+        venue_order_id: VenueOrderId,
+        process_order_event_handler: ShareableMessageHandler,
+        execute_order_event_handler: ShareableMessageHandler,
+        bitmex_cash_account_state_multi: AccountState,
+        mut simple_cache: Cache,
+    ) {
+        msgbus::register(
+            MessagingSwitchboard::exec_engine_process(),
+            process_order_event_handler.clone(),
+        );
+        msgbus::register(
+            MessagingSwitchboard::exec_engine_execute(),
+            execute_order_event_handler.clone(),
+        );
+
+        let quote = QuoteTick::new(
+            instrument_xbtusd_bitmex.id(),
+            Price::from("0.6109"),
+            Price::from("0.6110"),
+            Quantity::from("1000"),
+            Quantity::from("1000"),
+            UnixNanos::default(),
+            UnixNanos::default(),
+        );
+
+        simple_cache
+            .add_instrument(instrument_xbtusd_bitmex.clone())
+            .unwrap();
+
+        simple_cache
+            .add_account(AccountAny::Cash(cash_account(
+                bitmex_cash_account_state_multi,
+            )))
+            .unwrap();
+
+        simple_cache.add_quote(quote).unwrap();
+
+        let cache = Rc::new(RefCell::new(simple_cache));
+
+        let mut risk_engine = get_risk_engine(Some(cache.clone()), None, None, false);
+        let order = OrderTestBuilder::new(OrderType::Limit)
+            .instrument_id(instrument_xbtusd_bitmex.id())
+            .side(OrderSide::Buy)
+            .price(Price::from("100_000.0"))
+            .quantity(Quantity::from_str("440").unwrap())
+            .time_in_force(TimeInForce::Gtd)
+            .expire_time(UnixNanos::from(1_000)) // <-- Set expire time in the past
+            .build();
+
+        let submit_order = SubmitOrder::new(
+            trader_id,
+            client_id_binance,
+            strategy_id_ema_cross,
+            instrument_xbtusd_bitmex.id(),
+            client_order_id,
+            venue_order_id,
+            order,
+            None,
+            None,
+            UUID4::new(),
+            clock.timestamp_ns(),
+        )
+        .unwrap();
+
+        clock.set_time(UnixNanos::from(2_000)); // <-- Set time to 2,000 nanos past epoch
+
+        risk_engine.execute(TradingCommand::SubmitOrder(submit_order));
+
+        // TODO: Change command messages to not require owned orders
+    }
 }

nautilus_trader/risk/engine.pyx

@@ -33,13 +33,15 @@ from nautilus_trader.common.component cimport MessageBus
 from nautilus_trader.common.component cimport Throttler
 from nautilus_trader.common.messages cimport TradingStateChanged
 from nautilus_trader.core.correctness cimport Condition
+from nautilus_trader.core.datetime cimport unix_nanos_to_dt
 from nautilus_trader.core.message cimport Command
 from nautilus_trader.core.message cimport Event
 from nautilus_trader.core.rust.model cimport AccountType
 from nautilus_trader.core.rust.model cimport InstrumentClass
 from nautilus_trader.core.rust.model cimport OrderSide
 from nautilus_trader.core.rust.model cimport OrderStatus
 from nautilus_trader.core.rust.model cimport OrderType
+from nautilus_trader.core.rust.model cimport TimeInForce
 from nautilus_trader.core.rust.model cimport TradingState
 from nautilus_trader.core.rust.model cimport TriggerType
 from nautilus_trader.core.uuid cimport UUID4
@@ -109,7 +111,7 @@ cdef class RiskEngine(Component):
         Cache cache not None,
         Clock clock not None,
         config: RiskEngineConfig | None = None,
-    ):
+    ) -> None:
         if config is None:
             config = RiskEngineConfig()
         Condition.type(config, RiskEngineConfig, "config")
@@ -555,9 +557,18 @@ cdef class RiskEngine(Component):
         ########################################################################
         if not self._check_order_price(instrument, order):
             return False  # Denied
+
         if not self._check_order_quantity(instrument, order):
             return False  # Denied
 
+        if order.time_in_force == TimeInForce.GTD:
+            if order.expire_time_ns <= self._clock.timestamp_ns():
+                self._deny_order(
+                    order=order,
+                    reason=f"GTD {unix_nanos_to_dt(order.expire_time_ns)} already passed",
+                )
+                return False  # Denied
+
         return True  # Check passed
 
     cpdef bint _check_order_price(self, Instrument instrument, Order order):

tests/unit_tests/risk/test_engine.py

@@ -16,6 +16,7 @@
 from datetime import timedelta
 from decimal import Decimal
 
+import pandas as pd
 import pytest
 
 from nautilus_trader.common.component import MessageBus
@@ -40,6 +41,7 @@
 from nautilus_trader.model.enums import AccountType
 from nautilus_trader.model.enums import OrderSide
 from nautilus_trader.model.enums import OrderStatus
+from nautilus_trader.model.enums import TimeInForce
 from nautilus_trader.model.enums import TradingState
 from nautilus_trader.model.enums import TriggerType
 from nautilus_trader.model.events import AccountState
@@ -1956,6 +1958,43 @@ def test_modify_order_for_emulated_order_then_sends_to_emulator(self):
         # Assert
         assert order.trigger_price == new_trigger_price
 
+    def test_submit_order_with_passed_gtd(self):
+        # Arrange
+        self.exec_engine.start()
+
+        strategy = Strategy()
+        strategy.register(
+            trader_id=self.trader_id,
+            portfolio=self.portfolio,
+            msgbus=self.msgbus,
+            cache=self.cache,
+            clock=self.clock,
+        )
+
+        self.clock.set_time(2_000)  # <-- Set clock to 2,000 nanos past epoch
+
+        order = strategy.order_factory.stop_market(
+            _AUDUSD_SIM.id,
+            OrderSide.BUY,
+            Quantity.from_int(100_000),
+            Price.from_str("1.00020"),
+            time_in_force=TimeInForce.GTD,
+            expire_time=pd.Timestamp(1_000),  # <-- Expire time prior to time now
+        )
+        submit_order = SubmitOrder(
+            trader_id=order.trader_id,
+            strategy_id=order.strategy_id,
+            position_id=None,
+            order=order,
+            command_id=UUID4(),
+            ts_init=self.clock.timestamp_ns(),
+        )
+
+        self.risk_engine.execute(submit_order)
+
+        # Assert
+        assert order.status == OrderStatus.DENIED
+
 
 class TestRiskEngineWithBettingAccount:
     def setup(self):