Skip to main content

nautilus_execution/order_emulator/
emulator.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16use std::{cell::RefCell, collections::VecDeque, fmt::Debug, rc::Rc};
17
18use ahash::{AHashMap, AHashSet};
19use nautilus_common::{
20    cache::Cache,
21    clock::Clock,
22    logging::{CMD, EVT, RECV, SEND},
23    messages::{
24        data::{
25            DataCommand, SubscribeCommand, SubscribeQuotes, SubscribeTrades, UnsubscribeCommand,
26            UnsubscribeQuotes, UnsubscribeTrades,
27        },
28        execution::{
29            BatchModifyOrders, CancelAllOrders, CancelOrder, ModifyOrder, SubmitOrder,
30            SubmitOrderList, TradingCommand,
31        },
32    },
33    msgbus::{
34        self, MessagingSwitchboard, TypedHandler, TypedIntoHandler,
35        switchboard::{
36            get_event_order_topic, get_order_canceled_topic, get_quotes_topic, get_trades_topic,
37        },
38    },
39};
40use nautilus_core::{UUID4, WeakCell};
41use nautilus_model::{
42    data::{OrderBookDeltas, QuoteTick, TradeTick},
43    enums::{ContingencyType, OrderSide, OrderStatus, OrderType, TimeInForce, TriggerType},
44    events::{
45        OrderCancelDenied, OrderCanceled, OrderEmulated, OrderEventAny, OrderInitialized,
46        OrderModifyDenied, OrderReleased, OrderUpdated,
47    },
48    identifiers::{ClientOrderId, ExecAlgorithmId, InstrumentId, PositionId, StrategyId},
49    instruments::Instrument,
50    orders::{LimitOrder, MarketOrder, Order, OrderAny},
51    types::{Price, Quantity},
52};
53use ustr::Ustr;
54
55use super::{PendingMessage, handlers::OrderEmulatorOnEventHandler};
56use crate::{
57    matching::{MatchAction, OrderMatchingCore, RestingOrder},
58    order_manager::{OrderManagerAction, manager::OrderManager},
59    trailing::{store_trailing_stop_activation, trailing_stop_calculate},
60};
61
62pub struct OrderEmulator {
63    clock: Rc<RefCell<dyn Clock>>,
64    cache: Rc<RefCell<Cache>>,
65    manager: OrderManager,
66    matching_cores: AHashMap<InstrumentId, OrderMatchingCore>,
67    subscribed_strategies: AHashSet<StrategyId>,
68    monitored_positions: AHashSet<PositionId>,
69    quote_tick_handler: Option<TypedHandler<QuoteTick>>,
70    trade_tick_handler: Option<TypedHandler<TradeTick>>,
71    quote_handlers: AHashMap<InstrumentId, TypedHandler<QuoteTick>>,
72    trade_handlers: AHashMap<InstrumentId, TypedHandler<TradeTick>>,
73    on_event_handler: Option<TypedHandler<OrderEventAny>>,
74    pending_messages: Rc<RefCell<VecDeque<PendingMessage>>>,
75}
76
77impl Debug for OrderEmulator {
78    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
79        f.debug_struct(stringify!(OrderEmulator))
80            .field("cores", &self.matching_cores.len())
81            .field("subscribed_quotes", &self.quote_handlers.len())
82            .field("subscribed_trades", &self.trade_handlers.len())
83            .field("subscribed_strategies", &self.subscribed_strategies.len())
84            .finish()
85    }
86}
87
88impl OrderEmulator {
89    pub fn new(clock: Rc<RefCell<dyn Clock>>, cache: Rc<RefCell<Cache>>) -> Self {
90        let active_local = true;
91        let manager = OrderManager::new(clock.clone(), cache.clone(), active_local);
92
93        Self {
94            clock,
95            cache,
96            manager,
97            matching_cores: AHashMap::new(),
98            subscribed_strategies: AHashSet::new(),
99            monitored_positions: AHashSet::new(),
100            quote_tick_handler: None,
101            trade_tick_handler: None,
102            quote_handlers: AHashMap::new(),
103            trade_handlers: AHashMap::new(),
104            on_event_handler: None,
105            pending_messages: Rc::new(RefCell::new(VecDeque::new())),
106        }
107    }
108
109    pub fn register_msgbus_handlers(emulator: &Rc<RefCell<Self>>) {
110        let weak = WeakCell::from(Rc::downgrade(emulator));
111        let pending_messages = emulator.borrow().pending_messages.clone();
112
113        let execute_weak = weak.clone();
114        let execute_pending = pending_messages.clone();
115        let execute_handler = TypedIntoHandler::from(move |cmd: TradingCommand| {
116            if let Some(emulator) = execute_weak.upgrade() {
117                match emulator.try_borrow_mut() {
118                    Ok(mut emulator) => emulator.execute(cmd),
119                    Err(_) => execute_pending
120                        .borrow_mut()
121                        .push_back(PendingMessage::Command(Box::new(cmd))),
122                }
123            }
124        });
125        msgbus::register_trading_command_endpoint(
126            MessagingSwitchboard::order_emulator_execute(),
127            execute_handler,
128        );
129
130        let quote_weak = weak.clone();
131        let quote_handler = TypedHandler::from(move |quote: &QuoteTick| {
132            if let Some(emulator) = quote_weak.upgrade() {
133                emulator.borrow_mut().on_quote_tick(*quote);
134            }
135        });
136
137        let trade_weak = weak.clone();
138        let trade_handler = TypedHandler::from(move |trade: &TradeTick| {
139            if let Some(emulator) = trade_weak.upgrade() {
140                emulator.borrow_mut().on_trade_tick(*trade);
141            }
142        });
143
144        let on_event_handler = TypedHandler::new(OrderEmulatorOnEventHandler::new(
145            Ustr::from(UUID4::new().as_str()),
146            weak,
147            WeakCell::from(Rc::downgrade(&pending_messages)),
148        ));
149
150        let mut emulator = emulator.borrow_mut();
151        emulator.quote_tick_handler = Some(quote_handler);
152        emulator.trade_tick_handler = Some(trade_handler);
153        emulator.on_event_handler = Some(on_event_handler);
154    }
155
156    pub fn set_on_event_handler(&mut self, handler: TypedHandler<OrderEventAny>) {
157        self.on_event_handler = Some(handler);
158    }
159
160    /// Caches a submit order command for emulation tracking.
161    pub fn cache_submit_order_command(&mut self, command: SubmitOrder) {
162        self.manager.cache_submit_order_command(command);
163    }
164
165    /// Subscribes to quote data for the given instrument.
166    fn subscribe_quotes_for_instrument(&mut self, instrument_id: InstrumentId) {
167        if self.quote_handlers.contains_key(&instrument_id) {
168            log::warn!("OrderEmulator attempted duplicate quote subscription for {instrument_id}");
169            return;
170        }
171
172        let Some(handler) = self.quote_tick_handler.clone() else {
173            log::warn!("Cannot subscribe to quotes: msgbus handlers not registered");
174            return;
175        };
176
177        let topic = get_quotes_topic(instrument_id);
178        self.quote_handlers.insert(instrument_id, handler.clone());
179        msgbus::subscribe_quotes(topic.into(), handler, None);
180        self.send_data_command(DataCommand::Subscribe(SubscribeCommand::Quotes(
181            SubscribeQuotes::new(
182                instrument_id,
183                None,
184                Some(instrument_id.venue),
185                UUID4::new(),
186                self.clock.borrow().timestamp_ns(),
187                None,
188                None,
189            ),
190        )));
191    }
192
193    /// Subscribes to trade data for the given instrument.
194    fn subscribe_trades_for_instrument(&mut self, instrument_id: InstrumentId) {
195        if self.trade_handlers.contains_key(&instrument_id) {
196            log::warn!("OrderEmulator attempted duplicate trade subscription for {instrument_id}");
197            return;
198        }
199
200        let Some(handler) = self.trade_tick_handler.clone() else {
201            log::warn!("Cannot subscribe to trades: msgbus handlers not registered");
202            return;
203        };
204
205        let topic = get_trades_topic(instrument_id);
206        self.trade_handlers.insert(instrument_id, handler.clone());
207        msgbus::subscribe_trades(topic.into(), handler, None);
208        self.send_data_command(DataCommand::Subscribe(SubscribeCommand::Trades(
209            SubscribeTrades::new(
210                instrument_id,
211                None,
212                Some(instrument_id.venue),
213                UUID4::new(),
214                self.clock.borrow().timestamp_ns(),
215                None,
216                None,
217            ),
218        )));
219    }
220
221    #[must_use]
222    pub fn subscribed_quotes(&self) -> Vec<InstrumentId> {
223        let mut quotes: Vec<InstrumentId> = self.quote_handlers.keys().copied().collect();
224        quotes.sort();
225        quotes
226    }
227
228    #[must_use]
229    pub fn subscribed_trades(&self) -> Vec<InstrumentId> {
230        let mut trades: Vec<_> = self.trade_handlers.keys().copied().collect();
231        trades.sort();
232        trades
233    }
234
235    #[must_use]
236    pub fn subscribed_strategy_count(&self) -> usize {
237        self.subscribed_strategies.len()
238    }
239
240    #[must_use]
241    pub fn monitored_position_count(&self) -> usize {
242        self.monitored_positions.len()
243    }
244
245    #[must_use]
246    pub fn get_submit_order_commands(&self) -> AHashMap<ClientOrderId, SubmitOrder> {
247        self.manager.get_submit_order_commands()
248    }
249
250    #[must_use]
251    pub fn get_matching_core(&self, instrument_id: &InstrumentId) -> Option<OrderMatchingCore> {
252        self.matching_cores.get(instrument_id).cloned()
253    }
254
255    pub fn start(&mut self) {
256        if let Err(e) = self.on_start() {
257            log::error!("{e}");
258        }
259
260        log::info!("Started");
261    }
262
263    pub fn stop(&self) {
264        self.on_stop();
265
266        log::info!("Stopped");
267    }
268
269    pub fn reset(&mut self) {
270        self.on_reset();
271
272        log::info!("Reset");
273    }
274
275    pub fn dispose(&mut self) {
276        self.on_dispose();
277
278        log::info!("Disposed");
279    }
280
281    /// Reactivates emulated orders from cache on start.
282    ///
283    /// # Errors
284    ///
285    /// Returns an error if processing fails.
286    pub fn on_start(&mut self) -> anyhow::Result<()> {
287        let emulated_orders: Vec<ClientOrderId> = self
288            .cache
289            .borrow()
290            .orders_emulated(None, None, None, None, None)
291            .into_iter()
292            .map(|order| order.client_order_id())
293            .collect();
294
295        if emulated_orders.is_empty() {
296            log::debug!("No emulated orders to reactivate");
297            return Ok(());
298        }
299
300        for client_order_id in emulated_orders {
301            self.reactivate_order(client_order_id);
302        }
303
304        self.drain_pending_messages();
305
306        Ok(())
307    }
308
309    fn reactivate_order(&mut self, client_order_id: ClientOrderId) {
310        let Some(order) = self.cache.borrow().order_owned(&client_order_id) else {
311            return;
312        };
313
314        if !matches!(
315            order.status(),
316            OrderStatus::Initialized | OrderStatus::Emulated
317        ) {
318            return; // No longer emulated
319        }
320
321        if let Some(parent_order_id) = &order.parent_order_id() {
322            let parent_order = if let Some(order) = self.cache.borrow().order_owned(parent_order_id)
323            {
324                order
325            } else {
326                log::error!("Cannot handle order: parent {parent_order_id} not found");
327                return;
328            };
329
330            let is_position_closed = parent_order
331                .position_id()
332                .is_none_or(|id| self.cache.borrow().is_position_closed(&id));
333
334            if parent_order.is_closed() && is_position_closed {
335                let actions = self.manager.cancel_order(&order);
336                self.dispatch_manager_actions(actions);
337                return; // Parent already closed
338            }
339
340            if parent_order.contingency_type() == Some(ContingencyType::Oto)
341                && (parent_order.is_active_local()
342                    || parent_order.filled_qty() == Quantity::zero(0))
343            {
344                return; // Process contingency order later once parent triggered
345            }
346        }
347
348        let position_id = self
349            .cache
350            .borrow()
351            .position_id(&order.client_order_id())
352            .copied();
353        let client_id = self
354            .cache
355            .borrow()
356            .client_id(&order.client_order_id())
357            .copied();
358
359        let command = SubmitOrder::new(
360            order.trader_id(),
361            client_id,
362            order.strategy_id(),
363            order.instrument_id(),
364            order.client_order_id(),
365            order.init_event().clone(),
366            order.exec_algorithm_id(),
367            position_id,
368            None, // params
369            UUID4::new(),
370            self.clock.borrow().timestamp_ns(),
371            None, // correlation_id
372        );
373
374        self.manager.cache_submit_order_command(command.clone());
375        self.handle_submit_order(&command);
376    }
377
378    pub fn on_event(&mut self, event: &OrderEventAny) {
379        log::info!("{RECV}{EVT} {event}");
380
381        let actions = self.manager.handle_event(event);
382        self.dispatch_manager_actions(actions);
383
384        if let Some(order) = self.cache.borrow().order(&event.client_order_id())
385            && order.is_closed()
386            && let Some(matching_core) = self.matching_cores.get_mut(&order.instrument_id())
387            && let Err(e) = matching_core.delete_order(event.client_order_id())
388        {
389            log::debug!("Error deleting order: {e}");
390        }
391        // else: Order not in cache yet
392
393        self.drain_pending_messages();
394    }
395
396    fn drain_pending_messages(&mut self) {
397        loop {
398            let message = self.pending_messages.borrow_mut().pop_front();
399            match message {
400                Some(PendingMessage::Command(command)) => self.execute(*command),
401                Some(PendingMessage::Event(event)) => self.on_event(&event),
402                None => break,
403            }
404        }
405    }
406
407    pub const fn on_stop(&self) {}
408
409    pub fn on_reset(&mut self) {
410        self.manager.reset();
411        self.pending_messages.borrow_mut().clear();
412        self.matching_cores.clear();
413        self.unsubscribe_all_market_data();
414        self.unsubscribe_strategy_order_events();
415        self.monitored_positions.clear();
416    }
417
418    pub fn on_dispose(&mut self) {
419        self.on_reset();
420    }
421
422    fn unsubscribe_all_market_data(&mut self) {
423        // Sort so the emitted unsubscribe commands, and the UUID4 draws they consume,
424        // follow the same sequence across runs; the handler maps are AHash-backed.
425        let mut quote_instrument_ids: Vec<_> = self.quote_handlers.keys().copied().collect();
426        quote_instrument_ids.sort();
427
428        for instrument_id in quote_instrument_ids {
429            self.unsubscribe_quotes_for_instrument(instrument_id);
430        }
431
432        let mut trade_instrument_ids: Vec<_> = self.trade_handlers.keys().copied().collect();
433        trade_instrument_ids.sort();
434
435        for instrument_id in trade_instrument_ids {
436            self.unsubscribe_trades_for_instrument(instrument_id);
437        }
438    }
439
440    fn unsubscribe_quotes_for_instrument(&mut self, instrument_id: InstrumentId) {
441        if let Some(handler) = self.quote_handlers.remove(&instrument_id) {
442            let topic = get_quotes_topic(instrument_id);
443            msgbus::unsubscribe_quotes(topic.into(), &handler);
444        }
445
446        self.send_data_command(DataCommand::Unsubscribe(UnsubscribeCommand::Quotes(
447            UnsubscribeQuotes::new(
448                instrument_id,
449                None,
450                Some(instrument_id.venue),
451                UUID4::new(),
452                self.clock.borrow().timestamp_ns(),
453                None,
454                None,
455            ),
456        )));
457    }
458
459    fn unsubscribe_trades_for_instrument(&mut self, instrument_id: InstrumentId) {
460        if let Some(handler) = self.trade_handlers.remove(&instrument_id) {
461            let topic = get_trades_topic(instrument_id);
462            msgbus::unsubscribe_trades(topic.into(), &handler);
463        }
464
465        self.send_data_command(DataCommand::Unsubscribe(UnsubscribeCommand::Trades(
466            UnsubscribeTrades::new(
467                instrument_id,
468                None,
469                Some(instrument_id.venue),
470                UUID4::new(),
471                self.clock.borrow().timestamp_ns(),
472                None,
473                None,
474            ),
475        )));
476    }
477
478    fn unsubscribe_strategy_order_events(&mut self) {
479        let mut strategy_ids: Vec<_> = self.subscribed_strategies.drain().collect();
480        strategy_ids.sort();
481        let Some(handler) = &self.on_event_handler else {
482            return;
483        };
484
485        for strategy_id in strategy_ids {
486            msgbus::unsubscribe_order_events(format!("events.order.{strategy_id}").into(), handler);
487        }
488    }
489
490    pub fn execute(&mut self, command: TradingCommand) {
491        log::info!("{RECV}{CMD} {command}");
492
493        match command {
494            TradingCommand::SubmitOrder(command) => self.handle_submit_order(&command),
495            TradingCommand::SubmitOrderList(ref command) => self.handle_submit_order_list(command),
496            TradingCommand::ModifyOrder(ref command) => self.handle_modify_order(command),
497            TradingCommand::ModifyOrders(ref command) => self.handle_batch_modify_orders(command),
498            TradingCommand::CancelOrder(command) => self.handle_cancel_order(command),
499            TradingCommand::CancelAllOrders(ref command) => self.handle_cancel_all_orders(command),
500            _ => log::error!("Cannot handle command: unrecognized {command}"),
501        }
502
503        self.drain_pending_messages();
504    }
505
506    fn dispatch_manager_actions(&mut self, actions: Vec<OrderManagerAction>) {
507        for action in actions {
508            self.dispatch_manager_action(action);
509        }
510    }
511
512    fn dispatch_manager_action(&mut self, action: OrderManagerAction) {
513        match action {
514            OrderManagerAction::PublishInitialized(event) => publish_order_event(&event),
515            OrderManagerAction::SubmitToEmulator(command) => self.handle_submit_order(&command),
516            OrderManagerAction::SubmitToRisk(command) => {
517                self.send_risk_command(TradingCommand::SubmitOrder(command));
518            }
519            OrderManagerAction::SubmitToAlgorithm {
520                command,
521                exec_algorithm_id,
522            } => self.send_algo_command(command, exec_algorithm_id),
523            OrderManagerAction::CancelLocal(order) => self.cancel_order(&order),
524            OrderManagerAction::ModifyLocalQuantity {
525                mut order,
526                quantity,
527            } => {
528                self.update_order(&mut order, quantity);
529            }
530        }
531    }
532
533    /// # Panics
534    ///
535    /// Panics if the emulation trigger type is not set or if the order is not in the cache.
536    pub fn handle_submit_order(&mut self, command: &SubmitOrder) {
537        let client_order_id = command.client_order_id;
538
539        let mut order = self
540            .cache
541            .borrow()
542            .order_owned(&client_order_id)
543            .expect("order must exist in cache");
544
545        if order.is_closed() {
546            return;
547        }
548
549        let emulation_trigger = order.emulation_trigger();
550
551        if !self
552            .manager
553            .get_submit_order_commands()
554            .contains_key(&client_order_id)
555        {
556            self.manager.cache_submit_order_command(command.clone());
557        }
558
559        assert!(
560            emulation_trigger.is_some(),
561            "order.emulation_trigger must be set"
562        );
563
564        if !matches!(
565            emulation_trigger,
566            Some(TriggerType::Default | TriggerType::BidAsk | TriggerType::LastPrice)
567        ) {
568            log::error!("Cannot emulate order: `TriggerType` {emulation_trigger:?} not supported");
569            let actions = self.manager.cancel_order(&order);
570            self.dispatch_manager_actions(actions);
571            return;
572        }
573
574        let emulation_trigger = emulation_trigger.expect("emulation trigger must be set");
575        let strategy_id = command.strategy_id;
576        let position_id = command.position_id;
577
578        let trigger_instrument_id = order
579            .trigger_instrument_id()
580            .unwrap_or_else(|| order.instrument_id());
581
582        let Some(mut matching_core) =
583            self.get_or_create_matching_core(trigger_instrument_id, emulation_trigger)
584        else {
585            let actions = self.manager.cancel_order(&order);
586            self.dispatch_manager_actions(actions);
587            return;
588        };
589
590        // Update trailing stop
591        if matches!(
592            order.order_type(),
593            OrderType::TrailingStopMarket | OrderType::TrailingStopLimit
594        ) {
595            self.update_trailing_stop_order(&mut order);
596            if order.trigger_price().is_none() && is_order_activated(&order) {
597                log::error!(
598                    "Cannot handle trailing stop order with no trigger_price and no market updates"
599                );
600
601                let actions = self.manager.cancel_order(&order);
602                self.dispatch_manager_actions(actions);
603                return;
604            }
605            // Not yet activated: held inert until the activation price is touched
606        }
607
608        self.check_monitoring(strategy_id, position_id);
609
610        // Check if immediately marketable
611        let match_info = matching_core_entry(&order);
612
613        if let Some(action) = match_emulated_order(&matching_core, &match_info) {
614            self.dispatch_match_action(action);
615        }
616
617        // Handle data subscriptions
618        match emulation_trigger {
619            TriggerType::Default | TriggerType::BidAsk => {
620                if !self.quote_handlers.contains_key(&trigger_instrument_id) {
621                    self.subscribe_quotes_for_instrument(trigger_instrument_id);
622                }
623            }
624            TriggerType::LastPrice => {
625                if !self.trade_handlers.contains_key(&trigger_instrument_id) {
626                    self.subscribe_trades_for_instrument(trigger_instrument_id);
627                }
628            }
629            _ => {
630                log::error!("Invalid TriggerType: {emulation_trigger:?}");
631                return;
632            }
633        }
634
635        // Check if order was already released
636        if !self
637            .manager
638            .get_submit_order_commands()
639            .contains_key(&order.client_order_id())
640        {
641            return; // Already released
642        }
643
644        // Hold in matching core
645        matching_core.add_order(match_info);
646
647        if order.status() == OrderStatus::Initialized {
648            let event = OrderEmulated::new(
649                order.trader_id(),
650                order.strategy_id(),
651                order.instrument_id(),
652                order.client_order_id(),
653                UUID4::new(),
654                self.clock.borrow().timestamp_ns(),
655                self.clock.borrow().timestamp_ns(),
656            );
657
658            let event = OrderEventAny::Emulated(event);
659
660            order = match self.cache.borrow_mut().update_order(&event) {
661                Ok(order) => order,
662                Err(e) => {
663                    log::error!("Cannot apply order event: {e:?}");
664                    return;
665                }
666            };
667
668            self.send_risk_event(event.clone());
669
670            let topic = get_event_order_topic(order.strategy_id());
671            msgbus::publish_order_event(topic, &event);
672        }
673
674        // Since we are cloning the matching core, we need to insert it back into the original hashmap
675        self.matching_cores
676            .insert(trigger_instrument_id, matching_core);
677
678        log::info!("Emulating {order}");
679    }
680
681    fn get_or_create_matching_core(
682        &mut self,
683        instrument_id: InstrumentId,
684        emulation_trigger: TriggerType,
685    ) -> Option<OrderMatchingCore> {
686        if let Some(matching_core) = self.matching_cores.get_mut(&instrument_id) {
687            seed_matching_core(matching_core, &self.cache.borrow(), emulation_trigger);
688            return Some(matching_core.clone());
689        }
690
691        // Handle synthetic instruments
692        let (instrument_id, price_increment) = if instrument_id.is_synthetic() {
693            let synthetic = self.cache.borrow().try_synthetic(&instrument_id).cloned();
694
695            match synthetic {
696                Ok(synthetic) => (synthetic.id, synthetic.price_increment),
697                Err(e) => {
698                    log::error!("Cannot emulate order: {e}");
699                    return None;
700                }
701            }
702        } else {
703            let instrument = self.cache.borrow().instrument(&instrument_id).cloned();
704
705            if let Some(instrument) = instrument {
706                (instrument.id(), instrument.price_increment())
707            } else {
708                log::error!("Cannot emulate order: no instrument {instrument_id} for trigger");
709                return None;
710            }
711        };
712
713        let mut matching_core = OrderMatchingCore::new(instrument_id, price_increment);
714        seed_matching_core(&mut matching_core, &self.cache.borrow(), emulation_trigger);
715
716        self.matching_cores
717            .insert(instrument_id, matching_core.clone());
718
719        log::info!("Creating matching core for {instrument_id:?}");
720        Some(matching_core)
721    }
722
723    fn handle_submit_order_list(&mut self, command: &SubmitOrderList) {
724        self.check_monitoring(command.strategy_id, command.position_id);
725
726        let orders: Vec<OrderAny> = self
727            .cache
728            .borrow()
729            .orders_for_ids(&command.order_list.client_order_ids, &command);
730
731        for order in &orders {
732            let order = self.cache.borrow().order_owned(&order.client_order_id());
733
734            let Some(order) = order else {
735                continue;
736            };
737
738            if order.is_closed() {
739                continue;
740            }
741
742            if let Some(parent_order_id) = order.parent_order_id() {
743                let cache = self.cache.borrow();
744                let parent_order = if let Some(parent_order) = cache.order(&parent_order_id) {
745                    parent_order
746                } else {
747                    log::error!("Parent order for {} not found", order.client_order_id());
748                    continue;
749                };
750
751                if parent_order.contingency_type() == Some(ContingencyType::Oto) {
752                    continue; // Process contingency order later once parent triggered
753                }
754            }
755
756            match self.manager.create_new_submit_order(
757                &order,
758                command.position_id,
759                command.client_id,
760                command.correlation_id,
761            ) {
762                Ok(actions) => self.dispatch_manager_actions(actions),
763                Err(e) => log::error!("Error creating new submit order: {e}"),
764            }
765        }
766    }
767
768    fn handle_modify_order(&mut self, command: &ModifyOrder) {
769        let order = self.cache.borrow().order_owned(&command.client_order_id);
770
771        let Some(order) = order else {
772            self.deny_modify_command(command, "Order not found in cache");
773            return;
774        };
775
776        if order.is_closed() {
777            self.deny_modify_command(command, "Order already closed");
778            return;
779        }
780
781        let price = match command.price {
782            Some(price) => Some(price),
783            None => order.price(),
784        };
785
786        let trigger_price = match command.trigger_price {
787            Some(trigger_price) => Some(trigger_price),
788            None => order.trigger_price(),
789        };
790
791        let ts_now = self.clock.borrow().timestamp_ns();
792
793        let event = OrderUpdated::new(
794            order.trader_id(),
795            order.strategy_id(),
796            order.instrument_id(),
797            order.client_order_id(),
798            command.quantity.unwrap_or(order.quantity()),
799            UUID4::new(),
800            ts_now,
801            ts_now,
802            false,
803            order.venue_order_id(),
804            order.account_id(),
805            price,
806            trigger_price,
807            None,
808            order.is_quote_quantity(),
809        );
810
811        let event = OrderEventAny::Updated(event);
812
813        // Apply locally as for cancels, sending to the execution engine would re-enter it
814        // when a strategy modifies from an order or position event handler.
815        self.apply_order_event(&event);
816
817        // A synchronous event handler may supersede this update before dispatch returns
818        let order = self
819            .cache
820            .borrow()
821            .order(&command.client_order_id)
822            .filter(|order| order.last_event() == &event)
823            .map(|order| order.clone());
824
825        let Some(order) = order else {
826            return;
827        };
828
829        if !self
830            .manager
831            .get_submit_order_commands()
832            .contains_key(&command.client_order_id)
833        {
834            return;
835        }
836
837        let trigger_instrument_id = order
838            .trigger_instrument_id()
839            .unwrap_or_else(|| order.instrument_id());
840        let (action, match_info) = if let Some(matching_core) =
841            self.matching_cores.get_mut(&trigger_instrument_id)
842        {
843            if let Err(e) = matching_core.delete_order(order.client_order_id()) {
844                log::debug!("Cannot update order match info: {e:?}");
845            }
846
847            let match_info = matching_core_entry(&order);
848
849            (match_emulated_order(matching_core, &match_info), match_info)
850        } else {
851            log::error!(
852                "Cannot handle `ModifyOrder`: no matching core for trigger instrument {trigger_instrument_id}"
853            );
854            return;
855        };
856
857        if let Some(action) = action {
858            self.dispatch_match_action(action);
859        }
860
861        // Hold in matching core unless the match released the order
862        if self
863            .manager
864            .get_submit_order_commands()
865            .contains_key(&command.client_order_id)
866            && let Some(matching_core) = self.matching_cores.get_mut(&trigger_instrument_id)
867        {
868            matching_core.add_order(match_info);
869        }
870    }
871
872    fn handle_batch_modify_orders(&mut self, command: &BatchModifyOrders) {
873        for modify in &command.modifies {
874            self.handle_modify_order(modify);
875        }
876    }
877
878    pub fn handle_cancel_order(&mut self, command: CancelOrder) {
879        let order = self.cache.borrow().order_owned(&command.client_order_id);
880
881        let Some(order) = order else {
882            self.deny_cancel_command(&command, "Order not found in cache");
883            return;
884        };
885
886        if order.is_closed() {
887            self.deny_cancel_command(&command, "Order already closed");
888            return;
889        }
890
891        let trigger_instrument_id = order
892            .trigger_instrument_id()
893            .unwrap_or_else(|| order.instrument_id());
894
895        let matching_core = if let Some(core) = self.matching_cores.get(&trigger_instrument_id) {
896            core
897        } else {
898            let actions = self.manager.cancel_order(&order);
899            self.dispatch_manager_actions(actions);
900            return;
901        };
902
903        if !matching_core.order_exists(order.client_order_id())
904            && order.is_open()
905            && !order.is_pending_cancel()
906        {
907            // Order not held in the emulator
908            self.send_exec_command(TradingCommand::CancelOrder(command));
909        } else {
910            let actions = self.manager.cancel_order(&order);
911            self.dispatch_manager_actions(actions);
912        }
913    }
914
915    fn handle_cancel_all_orders(&mut self, command: &CancelAllOrders) {
916        let mut ids_to_cancel: Vec<ClientOrderId> = self
917            .matching_cores
918            .values()
919            .flat_map(OrderMatchingCore::iter_orders)
920            .map(|order| order.client_order_id)
921            .collect();
922        ids_to_cancel.sort_unstable();
923        ids_to_cancel.dedup();
924
925        {
926            let cache = self.cache.borrow();
927            ids_to_cancel.retain(|client_order_id| {
928                let Some(order) = cache.order(client_order_id) else {
929                    return false;
930                };
931
932                order.instrument_id() == command.instrument_id
933                    && command
934                        .order_side
935                        .is_none_or(|side| order.order_side() == side)
936                    && command.client_id.is_none_or(|client_id| {
937                        cache
938                            .client_id(client_order_id)
939                            .is_some_and(|order_client_id| *order_client_id == client_id)
940                    })
941            });
942        }
943
944        for id in ids_to_cancel {
945            let Some(order) = self.cache.borrow().order_owned(&id) else {
946                continue;
947            };
948            let actions = self.manager.cancel_order(&order);
949            self.dispatch_manager_actions(actions);
950        }
951    }
952
953    pub fn update_order(&mut self, order: &mut OrderAny, new_quantity: Quantity) {
954        log::info!(
955            "Updating order {} quantity to {new_quantity}",
956            order.client_order_id(),
957        );
958
959        let ts_now = self.clock.borrow().timestamp_ns();
960        let event = OrderUpdated::new(
961            order.trader_id(),
962            order.strategy_id(),
963            order.instrument_id(),
964            order.client_order_id(),
965            new_quantity,
966            UUID4::new(),
967            ts_now,
968            ts_now,
969            false,
970            None,
971            order.account_id(),
972            None,
973            None,
974            None,
975            order.is_quote_quantity(),
976        );
977
978        let event = OrderEventAny::Updated(event);
979
980        *order = match self.cache.borrow_mut().update_order(&event) {
981            Ok(order) => order,
982            Err(e) => {
983                log::error!("Cannot apply order event: {e:?}");
984                return;
985            }
986        };
987
988        self.send_risk_event(event);
989    }
990
991    pub fn on_order_book_deltas(&mut self, deltas: &OrderBookDeltas) {
992        log::debug!("Processing {deltas:?}");
993
994        let instrument_id = &deltas.instrument_id;
995        if let Some(matching_core) = self.matching_cores.get_mut(instrument_id) {
996            if let Some(book) = self.cache.borrow().order_book(instrument_id) {
997                let best_bid = book.best_bid_price();
998                let best_ask = book.best_ask_price();
999
1000                if let Some(best_bid) = best_bid {
1001                    matching_core.set_bid_raw(best_bid);
1002                }
1003
1004                if let Some(best_ask) = best_ask {
1005                    matching_core.set_ask_raw(best_ask);
1006                }
1007            } else {
1008                log::error!(
1009                    "Cannot handle `OrderBookDeltas`: no book being maintained for {}",
1010                    deltas.instrument_id
1011                );
1012            }
1013
1014            self.iterate_orders(instrument_id);
1015        } else {
1016            log::error!(
1017                "Cannot handle `OrderBookDeltas`: no matching core for instrument {}",
1018                deltas.instrument_id
1019            );
1020        }
1021    }
1022
1023    pub fn on_quote_tick(&mut self, quote: QuoteTick) {
1024        log::debug!("Processing {quote}:?");
1025
1026        let instrument_id = &quote.instrument_id;
1027        if let Some(matching_core) = self.matching_cores.get_mut(instrument_id) {
1028            matching_core.set_bid_raw(quote.bid_price);
1029            matching_core.set_ask_raw(quote.ask_price);
1030
1031            self.iterate_orders(instrument_id);
1032        } else {
1033            log::error!(
1034                "Cannot handle `QuoteTick`: no matching core for instrument {}",
1035                quote.instrument_id
1036            );
1037        }
1038    }
1039
1040    pub fn on_trade_tick(&mut self, trade: TradeTick) {
1041        log::debug!("Processing {trade:?}");
1042
1043        let instrument_id = &trade.instrument_id;
1044        if let Some(matching_core) = self.matching_cores.get_mut(instrument_id) {
1045            matching_core.set_last_raw(trade.price);
1046            self.iterate_orders(instrument_id);
1047        } else {
1048            log::error!(
1049                "Cannot handle `TradeTick`: no matching core for instrument {}",
1050                trade.instrument_id
1051            );
1052        }
1053    }
1054
1055    fn iterate_orders(&mut self, instrument_id: &InstrumentId) {
1056        // Process bid actions before ask actions so cross-side
1057        // contingencies (OCO/OUO) mutate state between sides
1058        let bid_actions = if let Some(matching_core) = self.matching_cores.get_mut(instrument_id) {
1059            matching_core
1060                .iter_bid_orders()
1061                .filter_map(|order| match_emulated_order(matching_core, order))
1062                .collect::<Vec<_>>()
1063        } else {
1064            log::error!("Cannot iterate orders: no matching core for instrument {instrument_id}");
1065            return;
1066        };
1067
1068        for action in bid_actions {
1069            self.dispatch_held_match(action, instrument_id);
1070        }
1071
1072        let ask_actions = if let Some(matching_core) = self.matching_cores.get_mut(instrument_id) {
1073            matching_core
1074                .iter_ask_orders()
1075                .filter_map(|order| match_emulated_order(matching_core, order))
1076                .collect::<Vec<_>>()
1077        } else {
1078            return;
1079        };
1080
1081        for action in ask_actions {
1082            self.dispatch_held_match(action, instrument_id);
1083        }
1084
1085        // Re-snapshot orders after actions to avoid stale trailing stop updates
1086        let orders = if let Some(matching_core) = self.matching_cores.get(instrument_id) {
1087            matching_core.get_orders()
1088        } else {
1089            return;
1090        };
1091
1092        for match_info in orders {
1093            if !matches!(
1094                match_info.order_type,
1095                OrderType::TrailingStopMarket | OrderType::TrailingStopLimit
1096            ) {
1097                continue;
1098            }
1099
1100            let mut order = match self.cache.borrow().order_owned(&match_info.client_order_id) {
1101                Some(order) => order,
1102                None => continue,
1103            };
1104
1105            if order.is_closed() {
1106                continue;
1107            }
1108
1109            self.update_trailing_stop_order(&mut order);
1110        }
1111
1112        self.drain_pending_messages();
1113    }
1114
1115    fn dispatch_held_match(&mut self, action: MatchAction, instrument_id: &InstrumentId) {
1116        let client_order_id = match action {
1117            MatchAction::FillLimit(id) | MatchAction::TriggerStop(id) => id,
1118        };
1119
1120        let Some(core) = self.matching_cores.get(instrument_id) else {
1121            return;
1122        };
1123
1124        let Some(order) = core.get_order(client_order_id) else {
1125            return;
1126        };
1127
1128        let Some(action) = match_emulated_order(core, order) else {
1129            return;
1130        };
1131
1132        self.dispatch_match_action(action);
1133    }
1134
1135    fn dispatch_match_action(&mut self, action: MatchAction) {
1136        match action {
1137            MatchAction::FillLimit(id) => self.fill_limit_order(id),
1138            MatchAction::TriggerStop(id) => self.trigger_stop_order(id),
1139        }
1140
1141        self.drain_pending_messages();
1142    }
1143
1144    pub fn cancel_order(&mut self, order: &OrderAny) {
1145        log::info!("Canceling order {}", order.client_order_id());
1146
1147        let mut order = order.clone();
1148        order.set_emulation_trigger(None);
1149
1150        let trigger_instrument_id = order
1151            .trigger_instrument_id()
1152            .unwrap_or(order.instrument_id());
1153
1154        if let Some(matching_core) = self.matching_cores.get_mut(&trigger_instrument_id)
1155            && let Err(e) = matching_core.delete_order(order.client_order_id())
1156        {
1157            log::debug!("Cannot delete order: {e:?}");
1158        }
1159
1160        self.manager
1161            .pop_submit_order_command(order.client_order_id());
1162
1163        self.cache
1164            .borrow_mut()
1165            .update_order_pending_cancel_local(&order);
1166
1167        let ts_now = self.clock.borrow().timestamp_ns();
1168        let event = OrderCanceled::new(
1169            order.trader_id(),
1170            order.strategy_id(),
1171            order.instrument_id(),
1172            order.client_order_id(),
1173            UUID4::new(),
1174            ts_now,
1175            ts_now,
1176            false,
1177            order.venue_order_id(),
1178            order.account_id(),
1179            None,
1180        );
1181
1182        self.apply_order_event(&OrderEventAny::Canceled(event));
1183    }
1184
1185    fn check_monitoring(&mut self, strategy_id: StrategyId, position_id: Option<PositionId>) {
1186        if !self.subscribed_strategies.contains(&strategy_id) {
1187            // Subscribe to strategy order events
1188            if let Some(handler) = &self.on_event_handler {
1189                msgbus::subscribe_order_events(
1190                    format!("events.order.{strategy_id}").into(),
1191                    handler.clone(),
1192                    None,
1193                );
1194                self.subscribed_strategies.insert(strategy_id);
1195                log::info!("Subscribed to strategy {strategy_id} order events");
1196            }
1197        }
1198
1199        if let Some(position_id) = position_id {
1200            self.monitored_positions.insert(position_id);
1201        }
1202    }
1203
1204    /// # Panics
1205    ///
1206    /// Panics if the order type is invalid for a stop order.
1207    pub fn trigger_stop_order(&mut self, client_order_id: ClientOrderId) {
1208        let order = match self.cache.borrow().order_owned(&client_order_id) {
1209            Some(order) => order,
1210            None => {
1211                log::error!(
1212                    "Cannot trigger stop order: order {client_order_id} not found in cache"
1213                );
1214                return;
1215            }
1216        };
1217
1218        match order.order_type() {
1219            OrderType::StopLimit | OrderType::LimitIfTouched | OrderType::TrailingStopLimit => {
1220                self.fill_limit_order(client_order_id);
1221            }
1222            OrderType::Market
1223            | OrderType::MarketIfTouched
1224            | OrderType::StopMarket
1225            | OrderType::TrailingStopMarket => self.fill_market_order(client_order_id),
1226            _ => panic!("invalid `OrderType`, was {}", order.order_type()),
1227        }
1228    }
1229
1230    /// Releases an emulated limit-type order as a limit order,
1231    /// or a plain limit order as a market order.
1232    ///
1233    /// Retains the command when market data is unavailable or the limit order cannot be built.
1234    /// Returns without releasing a limit-type order when its command is missing.
1235    ///
1236    /// # Panics
1237    ///
1238    /// Panics if a plain limit order is ready for market release but its command is missing.
1239    pub fn fill_limit_order(&mut self, client_order_id: ClientOrderId) {
1240        self.release_order(client_order_id, ReleaseType::Limit);
1241    }
1242
1243    /// Releases an emulated order as a market order, converting GTD to GTC.
1244    ///
1245    /// Retains the command when market data is unavailable.
1246    ///
1247    /// # Panics
1248    ///
1249    /// Panics if an order is ready for market release but its command is missing.
1250    pub fn fill_market_order(&mut self, client_order_id: ClientOrderId) {
1251        self.release_order(client_order_id, ReleaseType::Market);
1252    }
1253
1254    fn release_order(&mut self, client_order_id: ClientOrderId, release_type: ReleaseType) {
1255        let kind = match release_type {
1256            ReleaseType::Limit => "limit",
1257            ReleaseType::Market => "market",
1258        };
1259
1260        let Some(mut order) = self.cache.borrow().order_owned(&client_order_id) else {
1261            log::error!("Cannot fill {kind} order: order {client_order_id} not found in cache");
1262            return;
1263        };
1264
1265        if matches!(
1266            (release_type, order.order_type()),
1267            (ReleaseType::Limit, OrderType::Limit)
1268        ) {
1269            self.fill_market_order(client_order_id);
1270            return;
1271        }
1272
1273        let trigger_instrument_id = order
1274            .trigger_instrument_id()
1275            .unwrap_or(order.instrument_id());
1276
1277        let Some(matching_core) = self.matching_cores.get(&trigger_instrument_id) else {
1278            log::error!(
1279                "Cannot fill {kind} order: no matching core for instrument {trigger_instrument_id}"
1280            );
1281            return;
1282        };
1283
1284        let Some(released_price) =
1285            self.validate_release(&order, matching_core, trigger_instrument_id)
1286        else {
1287            return;
1288        };
1289
1290        // Build before taking the command, so a failed transform leaves the order emulated
1291        let limit_order = match release_type {
1292            ReleaseType::Limit => {
1293                let Some(transformed) = self.transform_limit_order(&order, trigger_instrument_id)
1294                else {
1295                    return;
1296                };
1297
1298                Some(transformed)
1299            }
1300            ReleaseType::Market => None,
1301        };
1302
1303        let command = self.manager.pop_submit_order_command(client_order_id);
1304
1305        let command = match release_type {
1306            ReleaseType::Limit => {
1307                let Some(command) = command else {
1308                    return;
1309                };
1310
1311                command
1312            }
1313            ReleaseType::Market => {
1314                command.expect("invalid operation `fill_market_order` with no command")
1315            }
1316        };
1317
1318        let Some(matching_core) = self.matching_cores.get_mut(&trigger_instrument_id) else {
1319            return;
1320        };
1321
1322        if let Err(e) = matching_core.delete_order(client_order_id) {
1323            match release_type {
1324                ReleaseType::Limit => log::debug!("Error deleting order: {e:?}"),
1325                ReleaseType::Market => log::debug!("Cannot delete order: {e:?}"),
1326            }
1327        }
1328
1329        let transformed = match limit_order {
1330            Some(mut transformed) => {
1331                transformed.liquidity_side = order.liquidity_side();
1332
1333                // TODO: fix
1334                // let triggered_price = order.trigger_price();
1335                // if triggered_price.is_some() {
1336                //     transformed.trigger_price() = (triggered_price.unwrap());
1337                // }
1338
1339                transformed.prepend_events(order.events().into_iter().cloned());
1340                OrderAny::Limit(transformed)
1341            }
1342            None => {
1343                order.set_emulation_trigger(None);
1344                let mut transformed = self.transform_market_order(&order);
1345                transformed.prepend_events(order.events().into_iter().cloned());
1346                OrderAny::Market(transformed)
1347            }
1348        };
1349
1350        self.submit_released_order(&order, &transformed, command, released_price, release_type);
1351    }
1352
1353    fn validate_release(
1354        &self,
1355        order: &OrderAny,
1356        matching_core: &OrderMatchingCore,
1357        trigger_instrument_id: InstrumentId,
1358    ) -> Option<Price> {
1359        let released_price = if order.emulation_trigger() == Some(TriggerType::LastPrice) {
1360            matching_core.last
1361        } else {
1362            match order.order_side() {
1363                OrderSide::Buy => matching_core.ask,
1364                OrderSide::Sell => matching_core.bid,
1365            }
1366        };
1367
1368        if released_price.is_none() {
1369            log::warn!(
1370                "Cannot release order {} yet: no market data available for {trigger_instrument_id}, will retry on next update",
1371                order.client_order_id(),
1372            );
1373            return None;
1374        }
1375
1376        released_price
1377    }
1378
1379    fn transform_limit_order(
1380        &self,
1381        order: &OrderAny,
1382        trigger_instrument_id: InstrumentId,
1383    ) -> Option<LimitOrder> {
1384        let client_order_id = order.client_order_id();
1385
1386        // A trailing stop limit has no limit price until its trailing calculation succeeds
1387        let Some(price) = order.price() else {
1388            log::warn!(
1389                "Cannot release order {client_order_id} yet: no limit price, will retry on next update"
1390            );
1391            return None;
1392        };
1393
1394        let transformed = match LimitOrder::new_checked(
1395            order.trader_id(),
1396            order.strategy_id(),
1397            order.instrument_id(),
1398            order.client_order_id(),
1399            order.order_side(),
1400            order.quantity(),
1401            price,
1402            order.time_in_force(),
1403            order.expire_time(),
1404            order.is_post_only(),
1405            order.is_reduce_only(),
1406            order.is_quote_quantity(),
1407            order.display_qty(),
1408            None,
1409            Some(trigger_instrument_id),
1410            order.contingency_type(),
1411            order.order_list_id(),
1412            order.linked_order_ids().map(Vec::from),
1413            order.parent_order_id(),
1414            order.exec_algorithm_id(),
1415            order.exec_algorithm_params().cloned(),
1416            order.exec_spawn_id(),
1417            order.tags().map(Vec::from),
1418            UUID4::new(),
1419            self.clock.borrow().timestamp_ns(),
1420        ) {
1421            Ok(transformed) => transformed,
1422            Err(e) => {
1423                log::error!("Cannot release order {client_order_id} as a limit order: {e}");
1424                return None;
1425            }
1426        };
1427
1428        Some(transformed)
1429    }
1430
1431    fn transform_market_order(&self, order: &OrderAny) -> MarketOrder {
1432        // Market orders reject GTD, so a released GTD order becomes GTC
1433        let time_in_force = match order.time_in_force() {
1434            TimeInForce::Gtd => TimeInForce::Gtc,
1435            time_in_force => time_in_force,
1436        };
1437
1438        MarketOrder::new(
1439            order.trader_id(),
1440            order.strategy_id(),
1441            order.instrument_id(),
1442            order.client_order_id(),
1443            order.order_side(),
1444            order.quantity(),
1445            time_in_force,
1446            UUID4::new(),
1447            self.clock.borrow().timestamp_ns(),
1448            order.is_reduce_only(),
1449            order.is_quote_quantity(),
1450            order.contingency_type(),
1451            order.order_list_id(),
1452            order.linked_order_ids().map(Vec::from),
1453            order.parent_order_id(),
1454            order.exec_algorithm_id(),
1455            order.exec_algorithm_params().cloned(),
1456            order.exec_spawn_id(),
1457            order.tags().map(Vec::from),
1458        )
1459    }
1460
1461    fn submit_released_order(
1462        &self,
1463        order: &OrderAny,
1464        transformed: &OrderAny,
1465        mut command: SubmitOrder,
1466        released_price: Price,
1467        release_type: ReleaseType,
1468    ) {
1469        let client_order_id = order.client_order_id();
1470        command.order_init = OrderInitialized::from(transformed);
1471        let add_result = self.cache.borrow_mut().add_order(
1472            transformed.clone(),
1473            command.position_id,
1474            command.client_id,
1475            true,
1476        );
1477
1478        if let Err(e) = add_result {
1479            log::error!("Failed to add order: {e}");
1480        } else {
1481            let topic = get_event_order_topic(order.strategy_id());
1482            msgbus::publish_order_event(topic, transformed.last_event());
1483        }
1484
1485        // Preserve the release branches' distinct clock-read and event-ID ordering
1486        let (event_id, ts_event, ts_init) = match release_type {
1487            ReleaseType::Limit => (
1488                UUID4::new(),
1489                self.clock.borrow().timestamp_ns(),
1490                self.clock.borrow().timestamp_ns(),
1491            ),
1492            ReleaseType::Market => {
1493                let ts_now = self.clock.borrow().timestamp_ns();
1494                (UUID4::new(), ts_now, ts_now)
1495            }
1496        };
1497
1498        let event = OrderEventAny::Released(OrderReleased::new(
1499            order.trader_id(),
1500            order.strategy_id(),
1501            order.instrument_id(),
1502            client_order_id,
1503            released_price,
1504            event_id,
1505            ts_event,
1506            ts_init,
1507        ));
1508
1509        let transformed = match self.cache.borrow_mut().update_order(&event) {
1510            Ok(order) => order,
1511            Err(e) => {
1512                log::error!("Failed to apply order event: {e}");
1513                return;
1514            }
1515        };
1516
1517        self.send_risk_event(event.clone());
1518
1519        log::info!("Releasing order {client_order_id}");
1520
1521        let strategy_id = match release_type {
1522            ReleaseType::Limit => transformed.strategy_id(),
1523            ReleaseType::Market => order.strategy_id(),
1524        };
1525
1526        let topic = get_event_order_topic(strategy_id);
1527        msgbus::publish_order_event(topic, &event);
1528
1529        if let Some(exec_algorithm_id) = order.exec_algorithm_id() {
1530            self.send_algo_command(command, exec_algorithm_id);
1531        } else {
1532            self.send_risk_command(TradingCommand::SubmitOrder(command));
1533        }
1534    }
1535
1536    fn update_trailing_stop_order(&mut self, order: &mut OrderAny) {
1537        let trigger_instrument_id = order
1538            .trigger_instrument_id()
1539            .unwrap_or_else(|| order.instrument_id());
1540
1541        let Some(matching_core) = self.matching_cores.get(&trigger_instrument_id) else {
1542            log::error!(
1543                "Cannot update trailing-stop order: no matching core for instrument {trigger_instrument_id}"
1544            );
1545            return;
1546        };
1547
1548        let mut bid = matching_core.bid;
1549        let mut ask = matching_core.ask;
1550        let mut last = matching_core.last;
1551        let price_increment = matching_core.price_increment;
1552        let instrument_id = matching_core.instrument_id;
1553        if bid.is_none() || ask.is_none() || last.is_none() {
1554            if let Some(q) = self.cache.borrow().quote(&instrument_id) {
1555                bid.get_or_insert(q.bid_price);
1556                ask.get_or_insert(q.ask_price);
1557            }
1558
1559            if let Some(t) = self.cache.borrow().trade(&instrument_id) {
1560                last.get_or_insert(t.price);
1561            }
1562        }
1563
1564        if order.emulation_trigger() == Some(TriggerType::LastPrice) {
1565            bid = last;
1566            ask = last;
1567        }
1568
1569        let was_activated = is_order_activated(order);
1570
1571        if !self.maybe_activate_trailing_stop(order, bid, ask, last) {
1572            return; // Not yet activated
1573        }
1574
1575        if !was_activated {
1576            // Activation transitioned: re-key the held entry from its inert
1577            // pre-activation state regardless of the trailing outcome below.
1578            self.refresh_matching_core_entry(order, trigger_instrument_id);
1579        }
1580
1581        let (new_trigger_px, new_limit_px) = match trailing_stop_calculate(
1582            price_increment,
1583            order.trigger_price(),
1584            order,
1585            bid,
1586            ask,
1587            last,
1588        ) {
1589            Ok(pair) => pair,
1590            Err(e) => {
1591                log::warn!("Cannot calculate trailing-stop update: {e}");
1592                return;
1593            }
1594        };
1595
1596        if new_trigger_px.is_none() && new_limit_px.is_none() {
1597            return;
1598        }
1599
1600        let ts_now = self.clock.borrow().timestamp_ns();
1601        let update = OrderUpdated::new(
1602            order.trader_id(),
1603            order.strategy_id(),
1604            order.instrument_id(),
1605            order.client_order_id(),
1606            order.quantity(),
1607            UUID4::new(),
1608            ts_now,
1609            ts_now,
1610            false,
1611            order.venue_order_id(),
1612            order.account_id(),
1613            new_limit_px,
1614            new_trigger_px,
1615            None,
1616            order.is_quote_quantity(),
1617        );
1618        let wrapped = OrderEventAny::Updated(update);
1619
1620        *order = match self.cache.borrow_mut().update_order(&wrapped) {
1621            Ok(order) => order,
1622            Err(e) => {
1623                log::error!("Failed to apply order event: {e}");
1624                return;
1625            }
1626        };
1627
1628        self.refresh_matching_core_entry(order, trigger_instrument_id);
1629
1630        self.send_risk_event(wrapped);
1631    }
1632
1633    fn refresh_matching_core_entry(
1634        &mut self,
1635        order: &OrderAny,
1636        trigger_instrument_id: InstrumentId,
1637    ) {
1638        if let Some(matching_core) = self.matching_cores.get_mut(&trigger_instrument_id) {
1639            if let Err(e) = matching_core.delete_order(order.client_order_id()) {
1640                log::debug!("Cannot update trailing-stop match info: {e:?}");
1641            }
1642
1643            // A trailing stop with no trigger price yet must stay inert:
1644            // its limit price must never match as a plain limit order.
1645            let (trigger_price, limit_price) = if order.trigger_price().is_some() {
1646                (order.trigger_price(), order.price())
1647            } else {
1648                (None, None)
1649            };
1650
1651            matching_core.add_order(RestingOrder::new_with_trigger_type(
1652                order.client_order_id(),
1653                order.order_side(),
1654                order.order_type(),
1655                order.emulation_trigger(),
1656                trigger_price,
1657                limit_price,
1658                is_order_activated(order),
1659            ));
1660        }
1661    }
1662
1663    /// Returns true if the trailing stop is (or has just become) activated.
1664    ///
1665    /// With no `activation_price` the order activates immediately at the current
1666    /// market price; otherwise it activates only once the market touches the
1667    /// activation price.
1668    fn maybe_activate_trailing_stop(
1669        &self,
1670        order: &mut OrderAny,
1671        bid: Option<Price>,
1672        ask: Option<Price>,
1673        last: Option<Price>,
1674    ) -> bool {
1675        let (is_activated, activation_price, trigger_type, order_side) = match order {
1676            OrderAny::TrailingStopMarket(inner) => (
1677                inner.is_activated,
1678                inner.activation_price,
1679                inner.trigger_type,
1680                inner.order_side(),
1681            ),
1682            OrderAny::TrailingStopLimit(inner) => (
1683                inner.is_activated,
1684                inner.activation_price,
1685                inner.trigger_type,
1686                inner.order_side(),
1687            ),
1688            _ => return true,
1689        };
1690
1691        if is_activated {
1692            return true;
1693        }
1694
1695        if let Some(activation_price) = activation_price {
1696            let hit = match order_side {
1697                OrderSide::Buy => ask.is_some_and(|a| a <= activation_price),
1698                OrderSide::Sell => bid.is_some_and(|b| b >= activation_price),
1699            };
1700
1701            if hit {
1702                Self::set_trailing_stop_activated(order, None);
1703                store_trailing_stop_activation(&mut self.cache.borrow_mut(), order);
1704            }
1705            return hit;
1706        }
1707
1708        let market_price = match trigger_type {
1709            TriggerType::LastPrice => last,
1710            _ => match order_side {
1711                OrderSide::Buy => ask,
1712                OrderSide::Sell => bid,
1713            },
1714        };
1715
1716        let Some(market_price) = market_price else {
1717            return false;
1718        };
1719
1720        Self::set_trailing_stop_activated(order, Some(market_price));
1721        store_trailing_stop_activation(&mut self.cache.borrow_mut(), order);
1722        true
1723    }
1724
1725    fn set_trailing_stop_activated(order: &mut OrderAny, activation_price: Option<Price>) {
1726        match order {
1727            OrderAny::TrailingStopMarket(inner) => {
1728                if let Some(price) = activation_price {
1729                    inner.activation_price = Some(price);
1730                }
1731                inner.set_activated();
1732            }
1733            OrderAny::TrailingStopLimit(inner) => {
1734                if let Some(price) = activation_price {
1735                    inner.activation_price = Some(price);
1736                }
1737                inner.set_activated();
1738            }
1739            _ => {}
1740        }
1741    }
1742
1743    fn send_algo_command(&self, command: SubmitOrder, exec_algorithm_id: ExecAlgorithmId) {
1744        let id = command.strategy_id;
1745        log::info!("{id} {CMD}{SEND} {command}");
1746
1747        let endpoint = format!("{exec_algorithm_id}.execute");
1748        msgbus::send_any(endpoint.into(), &TradingCommand::SubmitOrder(command));
1749    }
1750
1751    fn send_risk_command(&self, command: TradingCommand) {
1752        log_cmd_send(&command);
1753        let endpoint = MessagingSwitchboard::risk_engine_queue_execute();
1754        msgbus::send_trading_command(endpoint, command);
1755    }
1756
1757    fn send_exec_command(&self, command: TradingCommand) {
1758        log_cmd_send(&command);
1759        let endpoint = MessagingSwitchboard::exec_engine_queue_execute();
1760        msgbus::send_trading_command(endpoint, command);
1761    }
1762
1763    fn send_risk_event(&self, event: OrderEventAny) {
1764        log_evt_send(&event);
1765        let endpoint = MessagingSwitchboard::risk_engine_process();
1766        msgbus::send_order_event(endpoint, event);
1767    }
1768
1769    // Applies an event the emulator generated, then notifies the portfolio and the strategy
1770    fn apply_order_event(&self, event: &OrderEventAny) {
1771        if let Err(e) = self.cache.borrow_mut().update_order(event) {
1772            log::error!("Failed to apply order event: {e}");
1773            return;
1774        }
1775
1776        self.send_portfolio_order_event(event.clone());
1777        publish_order_event(event);
1778    }
1779
1780    fn send_portfolio_order_event(&self, event: OrderEventAny) {
1781        log_evt_send(&event);
1782        let endpoint = MessagingSwitchboard::portfolio_update_order();
1783        msgbus::send_order_event(endpoint, event);
1784    }
1785
1786    fn send_data_command(&self, command: DataCommand) {
1787        log::info!("{CMD}{SEND} {command:?}");
1788        let endpoint = MessagingSwitchboard::data_engine_queue_execute();
1789        msgbus::send_data_command(endpoint, command);
1790    }
1791
1792    fn deny_modify_command(&self, command: &ModifyOrder, reason: &str) {
1793        let ts_now = self.clock.borrow().timestamp_ns();
1794        let order = self.cache.borrow().order_owned(&command.client_order_id);
1795
1796        let mut event = OrderModifyDenied::new(
1797            order.as_ref().map_or(command.trader_id, Order::trader_id),
1798            order
1799                .as_ref()
1800                .map_or(command.strategy_id, Order::strategy_id),
1801            order
1802                .as_ref()
1803                .map_or(command.instrument_id, Order::instrument_id),
1804            command.client_order_id,
1805            reason.into(),
1806            UUID4::new(),
1807            ts_now,
1808            ts_now,
1809            order
1810                .as_ref()
1811                .and_then(Order::venue_order_id)
1812                .or(command.venue_order_id),
1813            order.as_ref().and_then(Order::account_id),
1814        );
1815        event.causation_id = Some(command.command_id);
1816        self.apply_command_denied(&OrderEventAny::ModifyDenied(event));
1817    }
1818
1819    fn deny_cancel_command(&self, command: &CancelOrder, reason: &str) {
1820        let ts_now = self.clock.borrow().timestamp_ns();
1821        let order = self.cache.borrow().order_owned(&command.client_order_id);
1822
1823        let mut event = OrderCancelDenied::new(
1824            order.as_ref().map_or(command.trader_id, Order::trader_id),
1825            order
1826                .as_ref()
1827                .map_or(command.strategy_id, Order::strategy_id),
1828            order
1829                .as_ref()
1830                .map_or(command.instrument_id, Order::instrument_id),
1831            command.client_order_id,
1832            reason.into(),
1833            UUID4::new(),
1834            ts_now,
1835            ts_now,
1836            order
1837                .as_ref()
1838                .and_then(Order::venue_order_id)
1839                .or(command.venue_order_id),
1840            order.as_ref().and_then(Order::account_id),
1841        );
1842        event.causation_id = Some(command.command_id);
1843        self.apply_command_denied(&OrderEventAny::CancelDenied(event));
1844    }
1845
1846    fn apply_command_denied(&self, event: &OrderEventAny) {
1847        if self.cache.borrow().order_exists(&event.client_order_id()) {
1848            self.apply_order_event(event);
1849        } else {
1850            publish_order_event(event);
1851        }
1852    }
1853}
1854
1855#[derive(Clone, Copy)]
1856enum ReleaseType {
1857    Limit,
1858    Market,
1859}
1860
1861fn publish_order_event(event: &OrderEventAny) {
1862    msgbus::publish_order_event(get_event_order_topic(event.strategy_id()), event);
1863    let topic = match event {
1864        OrderEventAny::Canceled(_) => get_order_canceled_topic(event.instrument_id()),
1865        OrderEventAny::ModifyDenied(_) => {
1866            msgbus::switchboard::get_order_modify_denied_topic(event.instrument_id())
1867        }
1868        OrderEventAny::CancelDenied(_) => {
1869            msgbus::switchboard::get_order_cancel_denied_topic(event.instrument_id())
1870        }
1871        _ => return,
1872    };
1873
1874    msgbus::publish_order_event(topic, event);
1875}
1876
1877fn seed_matching_core(core: &mut OrderMatchingCore, cache: &Cache, trigger: TriggerType) {
1878    if trigger == TriggerType::LastPrice {
1879        if core.last.is_none()
1880            && let Some(trade) = cache.trade(&core.instrument_id)
1881        {
1882            core.set_last_raw(trade.price);
1883        }
1884    } else if (core.bid.is_none() || core.ask.is_none())
1885        && let Some(quote) = cache.quote(&core.instrument_id)
1886    {
1887        core.set_bid_raw(quote.bid_price);
1888        core.set_ask_raw(quote.ask_price);
1889    }
1890}
1891
1892fn match_emulated_order(core: &OrderMatchingCore, order: &RestingOrder) -> Option<MatchAction> {
1893    if order.is_limit() && order.trigger_type == Some(TriggerType::LastPrice) {
1894        core.is_touch_triggered_with_trigger_type(
1895            order.order_side,
1896            order.limit_price?,
1897            TriggerType::LastPrice,
1898        )
1899        .then_some(MatchAction::FillLimit(order.client_order_id))
1900    } else {
1901        core.match_order(order)
1902    }
1903}
1904
1905fn matching_core_entry(order: &OrderAny) -> RestingOrder {
1906    let is_activated = is_order_activated(order);
1907    RestingOrder::new_with_trigger_type(
1908        order.client_order_id(),
1909        order.order_side(),
1910        order.order_type(),
1911        order.emulation_trigger(),
1912        if is_activated {
1913            order.trigger_price()
1914        } else {
1915            None
1916        },
1917        if is_activated { order.price() } else { None },
1918        is_activated,
1919    )
1920}
1921
1922fn is_order_activated(order: &OrderAny) -> bool {
1923    match order {
1924        OrderAny::TrailingStopMarket(o) => o.is_activated,
1925        OrderAny::TrailingStopLimit(o) => o.is_activated,
1926        _ => true,
1927    }
1928}
1929
1930fn log_cmd_send(command: &TradingCommand) {
1931    if let Some(id) = command.strategy_id() {
1932        log::info!("{id} {CMD}{SEND} {command}");
1933    } else {
1934        log::info!("{CMD}{SEND} {command}");
1935    }
1936}
1937
1938fn log_evt_send(event: &OrderEventAny) {
1939    let id = event.strategy_id();
1940    log::info!("{id} {EVT}{SEND} {event}");
1941}
1942
1943#[cfg(test)]
1944mod tests {
1945    use std::{cell::RefCell, rc::Rc};
1946
1947    use nautilus_common::{
1948        cache::Cache,
1949        clock::VirtualClock,
1950        messages::data::{DataCommand, SubscribeCommand, UnsubscribeCommand},
1951        msgbus::{
1952            MessagingSwitchboard,
1953            stubs::{
1954                TypedIntoMessageSavingHandler, get_any_saving_handler,
1955                get_typed_into_message_saving_handler,
1956            },
1957        },
1958    };
1959    use nautilus_core::{Params, UUID4, UnixNanos};
1960    use nautilus_model::{
1961        data::{QuoteTick, TradeTick},
1962        enums::{
1963            AggressorSide, OrderSide, OrderType, TimeInForce, TrailingOffsetType, TriggerType,
1964        },
1965        identifiers::{
1966            AccountId, ClientId, ClientOrderId, OrderListId, StrategyId, Symbol, TradeId, TraderId,
1967            VenueOrderId,
1968        },
1969        instruments::{
1970            CryptoPerpetual, Instrument, InstrumentAny, SyntheticInstrument,
1971            stubs::{btcusd_bybit, crypto_perpetual_ethusdt},
1972        },
1973        orders::{OrderList, OrderTestBuilder, stubs::TestOrderEventStubs},
1974        types::{Price, Quantity},
1975    };
1976    use rstest::{fixture, rstest};
1977    use rust_decimal_macros::dec;
1978    use ustr::Ustr;
1979
1980    use super::*;
1981
1982    #[fixture]
1983    fn instrument() -> CryptoPerpetual {
1984        crypto_perpetual_ethusdt()
1985    }
1986
1987    #[expect(clippy::type_complexity)]
1988    fn create_emulator() -> (
1989        Rc<RefCell<dyn Clock>>,
1990        Rc<RefCell<Cache>>,
1991        Rc<RefCell<OrderEmulator>>,
1992    ) {
1993        let clock: Rc<RefCell<dyn Clock>> = Rc::new(RefCell::new(VirtualClock::new()));
1994        let cache = Rc::new(RefCell::new(Cache::new(None, None)));
1995        let emulator = Rc::new(RefCell::new(OrderEmulator::new(
1996            clock.clone(),
1997            cache.clone(),
1998        )));
1999
2000        OrderEmulator::register_msgbus_handlers(&emulator);
2001
2002        (clock, cache, emulator)
2003    }
2004
2005    fn create_stop_market_order(instrument: &CryptoPerpetual, trigger: TriggerType) -> OrderAny {
2006        OrderTestBuilder::new(OrderType::StopMarket)
2007            .instrument_id(instrument.id())
2008            .side(OrderSide::Buy)
2009            .trigger_price(Price::from("5100.00"))
2010            .quantity(Quantity::from(1))
2011            .emulation_trigger(trigger)
2012            .build()
2013    }
2014
2015    fn create_stop_limit_order(instrument: &CryptoPerpetual, trigger: TriggerType) -> OrderAny {
2016        OrderTestBuilder::new(OrderType::StopLimit)
2017            .instrument_id(instrument.id())
2018            .side(OrderSide::Buy)
2019            .price(Price::from("5100.00"))
2020            .trigger_price(Price::from("5100.00"))
2021            .quantity(Quantity::from(1))
2022            .emulation_trigger(trigger)
2023            .build()
2024    }
2025
2026    fn create_list_stop_market_order(
2027        instrument: &CryptoPerpetual,
2028        client_order_id: &str,
2029        order_list_id: OrderListId,
2030    ) -> OrderAny {
2031        OrderTestBuilder::new(OrderType::StopMarket)
2032            .instrument_id(instrument.id())
2033            .client_order_id(ClientOrderId::from(client_order_id))
2034            .order_list_id(order_list_id)
2035            .side(OrderSide::Buy)
2036            .trigger_price(Price::from("5100.00"))
2037            .quantity(Quantity::from(1))
2038            .emulation_trigger(TriggerType::BidAsk)
2039            .build()
2040    }
2041
2042    fn create_submit_order(instrument: &CryptoPerpetual, order: &OrderAny) -> SubmitOrder {
2043        SubmitOrder::new(
2044            TraderId::from("TRADER-001"),
2045            None,
2046            StrategyId::from("STRATEGY-001"),
2047            instrument.id(),
2048            order.client_order_id(),
2049            order.init_event().clone(),
2050            None,
2051            None,
2052            None,
2053            UUID4::new(),
2054            0.into(),
2055            None, // correlation_id
2056        )
2057    }
2058
2059    fn create_quote_tick(instrument: &CryptoPerpetual, bid: &str, ask: &str) -> QuoteTick {
2060        QuoteTick::new(
2061            instrument.id(),
2062            Price::from(bid),
2063            Price::from(ask),
2064            Quantity::from(10),
2065            Quantity::from(10),
2066            0.into(),
2067            0.into(),
2068        )
2069    }
2070
2071    fn create_trade_tick(instrument: &CryptoPerpetual, price: &str) -> TradeTick {
2072        TradeTick::new(
2073            instrument.id(),
2074            Price::from(price),
2075            Quantity::from(1),
2076            AggressorSide::Buy,
2077            TradeId::from("T-001"),
2078            0.into(),
2079            0.into(),
2080        )
2081    }
2082
2083    fn add_instrument_to_cache(cache: &Rc<RefCell<Cache>>, instrument: &CryptoPerpetual) {
2084        cache
2085            .borrow_mut()
2086            .add_instrument(InstrumentAny::CryptoPerpetual(instrument.clone()))
2087            .unwrap();
2088    }
2089
2090    fn register_risk_event_handler(id: &str) -> TypedIntoMessageSavingHandler<OrderEventAny> {
2091        let (handler, saving_handler) =
2092            get_typed_into_message_saving_handler::<OrderEventAny>(Some(Ustr::from(id)));
2093        msgbus::register_order_event_endpoint(MessagingSwitchboard::risk_engine_process(), handler);
2094        saving_handler
2095    }
2096
2097    fn register_exec_event_handler(
2098        cache: Rc<RefCell<Cache>>,
2099        id: &str,
2100    ) -> TypedIntoMessageSavingHandler<OrderEventAny> {
2101        let messages = Rc::new(RefCell::new(Vec::new()));
2102        let messages_for_handler = messages.clone();
2103        msgbus::register_order_event_endpoint(
2104            MessagingSwitchboard::exec_engine_process(),
2105            TypedIntoHandler::from(move |event: OrderEventAny| {
2106                cache.borrow_mut().update_order(&event).unwrap();
2107                messages_for_handler.borrow_mut().push(event);
2108            }),
2109        );
2110        TypedIntoMessageSavingHandler::new_with_messages(Some(Ustr::from(id)), messages)
2111    }
2112
2113    fn register_portfolio_event_handler(id: &str) -> TypedIntoMessageSavingHandler<OrderEventAny> {
2114        let (handler, saving_handler) =
2115            get_typed_into_message_saving_handler::<OrderEventAny>(Some(Ustr::from(id)));
2116        msgbus::register_order_event_endpoint(
2117            MessagingSwitchboard::portfolio_update_order(),
2118            handler,
2119        );
2120        saving_handler
2121    }
2122
2123    fn register_data_command_handler(id: &str) -> TypedIntoMessageSavingHandler<DataCommand> {
2124        let (handler, saving_handler) =
2125            get_typed_into_message_saving_handler::<DataCommand>(Some(Ustr::from(id)));
2126        msgbus::register_data_command_endpoint(
2127            MessagingSwitchboard::data_engine_queue_execute(),
2128            handler,
2129        );
2130        saving_handler
2131    }
2132
2133    fn subscribe_order_topic(
2134        strategy_id: StrategyId,
2135    ) -> (TypedHandler<OrderEventAny>, Rc<RefCell<Vec<OrderEventAny>>>) {
2136        let events = Rc::new(RefCell::new(Vec::new()));
2137        let handler = TypedHandler::from({
2138            let events = events.clone();
2139            move |event: &OrderEventAny| {
2140                events.borrow_mut().push(event.clone());
2141            }
2142        });
2143        msgbus::subscribe_order_events(
2144            format!("events.order.{strategy_id}").into(),
2145            handler.clone(),
2146            None,
2147        );
2148        (handler, events)
2149    }
2150
2151    fn subscribe_order_cancel_topic(
2152        instrument_id: InstrumentId,
2153    ) -> (TypedHandler<OrderEventAny>, Rc<RefCell<Vec<OrderEventAny>>>) {
2154        let events = Rc::new(RefCell::new(Vec::new()));
2155        let handler = TypedHandler::from({
2156            let events = events.clone();
2157            move |event: &OrderEventAny| {
2158                events.borrow_mut().push(event.clone());
2159            }
2160        });
2161        msgbus::subscribe_order_events(
2162            get_order_canceled_topic(instrument_id).into(),
2163            handler.clone(),
2164            None,
2165        );
2166        (handler, events)
2167    }
2168
2169    #[rstest]
2170    #[case::modify(false)]
2171    #[case::cancel(true)]
2172    fn test_command_refusal_preserves_closed_or_absent_order(
2173        #[case] cancel: bool,
2174        #[values(false, true)] cached: bool,
2175        instrument: CryptoPerpetual,
2176    ) {
2177        let (_clock, cache, emulator) = create_emulator();
2178        let mut order = create_stop_market_order(&instrument, TriggerType::BidAsk);
2179
2180        if cached {
2181            let event = TestOrderEventStubs::canceled(
2182                &order,
2183                AccountId::from("SIM-001"),
2184                Some(VenueOrderId::from("V-CLOSED")),
2185            );
2186            order.apply(event).unwrap();
2187            cache
2188                .borrow_mut()
2189                .add_order(order.clone(), None, None, false)
2190                .unwrap();
2191        }
2192
2193        let (handler, events) = subscribe_order_topic(order.strategy_id());
2194        let cause = UUID4::new();
2195
2196        if cancel {
2197            emulator.borrow_mut().handle_cancel_order(CancelOrder::new(
2198                order.trader_id(),
2199                None,
2200                order.strategy_id(),
2201                order.instrument_id(),
2202                order.client_order_id(),
2203                order.venue_order_id(),
2204                cause,
2205                UnixNanos::from(17),
2206                None,
2207                None,
2208            ));
2209        } else {
2210            emulator.borrow_mut().handle_modify_order(&ModifyOrder::new(
2211                order.trader_id(),
2212                None,
2213                order.strategy_id(),
2214                order.instrument_id(),
2215                order.client_order_id(),
2216                order.venue_order_id(),
2217                Some(Quantity::from(2)),
2218                None,
2219                None,
2220                cause,
2221                UnixNanos::from(17),
2222                None,
2223                None,
2224            ));
2225        }
2226
2227        msgbus::unsubscribe_order_events(
2228            format!("events.order.{}", order.strategy_id()).into(),
2229            &handler,
2230        );
2231        let events = events.borrow();
2232        assert_eq!(events.len(), 1);
2233
2234        let (actual_cause, reason) = match &events[0] {
2235            OrderEventAny::ModifyDenied(event) if !cancel => {
2236                (event.causation_id, event.reason.as_str())
2237            }
2238            OrderEventAny::CancelDenied(event) if cancel => {
2239                (event.causation_id, event.reason.as_str())
2240            }
2241            event => panic!("unexpected command outcome {event:?}"),
2242        };
2243
2244        assert_eq!(actual_cause, Some(cause));
2245        assert_eq!(
2246            reason,
2247            if cached {
2248                "Order already closed"
2249            } else {
2250                "Order not found in cache"
2251            }
2252        );
2253        assert_eq!(events[0].trader_id(), order.trader_id());
2254        assert_eq!(events[0].strategy_id(), order.strategy_id());
2255        assert_eq!(events[0].instrument_id(), order.instrument_id());
2256        assert_eq!(events[0].client_order_id(), order.client_order_id());
2257        assert_eq!(events[0].venue_order_id(), order.venue_order_id());
2258        assert_eq!(events[0].account_id(), order.account_id());
2259
2260        if cached {
2261            let cache = cache.borrow();
2262            let actual = cache.order(&order.client_order_id()).unwrap();
2263            assert_eq!(actual.status(), order.status());
2264            assert_eq!(actual.quantity(), order.quantity());
2265            assert_eq!(actual.filled_qty(), order.filled_qty());
2266            assert_eq!(actual.price(), order.price());
2267            assert_eq!(actual.trigger_price(), order.trigger_price());
2268            assert_eq!(actual.ts_closed(), order.ts_closed());
2269        } else {
2270            assert!(!cache.borrow().order_exists(&order.client_order_id()));
2271        }
2272    }
2273
2274    #[rstest]
2275    fn test_dispatch_manager_publish_initialized_publishes_order_event(
2276        instrument: CryptoPerpetual,
2277    ) {
2278        let (_clock, _cache, emulator) = create_emulator();
2279        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
2280        let strategy_id = order.strategy_id();
2281        let client_order_id = order.client_order_id();
2282        let event = OrderEventAny::Initialized(order.init_event().clone());
2283        let (order_handler, order_events) = subscribe_order_topic(strategy_id);
2284
2285        emulator
2286            .borrow_mut()
2287            .dispatch_manager_action(OrderManagerAction::PublishInitialized(event));
2288        msgbus::unsubscribe_order_events(
2289            format!("events.order.{strategy_id}").into(),
2290            &order_handler,
2291        );
2292        let order_events = order_events.borrow();
2293
2294        assert_eq!(order_events.len(), 1);
2295        assert!(matches!(
2296            &order_events[0],
2297            OrderEventAny::Initialized(event) if event.client_order_id == client_order_id
2298        ));
2299    }
2300
2301    #[rstest]
2302    fn test_dispatch_manager_submit_to_emulator_applies_emulated_event(
2303        instrument: CryptoPerpetual,
2304    ) {
2305        let (_clock, cache, emulator) = create_emulator();
2306        let risk_events = register_risk_event_handler("RiskEngine.process.dispatch_emulated");
2307        add_instrument_to_cache(&cache, &instrument);
2308        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
2309        let client_order_id = order.client_order_id();
2310        let command = create_submit_order(&instrument, &order);
2311        cache
2312            .borrow_mut()
2313            .add_order(order, None, None, false)
2314            .unwrap();
2315        emulator
2316            .borrow_mut()
2317            .cache_submit_order_command(command.clone());
2318
2319        emulator
2320            .borrow_mut()
2321            .dispatch_manager_action(OrderManagerAction::SubmitToEmulator(command));
2322        let cache = cache.borrow();
2323        let cached_order = cache.order(&client_order_id).unwrap();
2324        let risk_events = risk_events.get_messages();
2325
2326        assert_eq!(cached_order.status(), OrderStatus::Emulated);
2327        assert_eq!(risk_events.len(), 1);
2328        assert!(matches!(risk_events[0], OrderEventAny::Emulated(_)));
2329    }
2330
2331    #[rstest]
2332    fn test_registered_execute_endpoint_routes_submit_order(instrument: CryptoPerpetual) {
2333        let (_clock, cache, emulator) = create_emulator();
2334        let risk_events = register_risk_event_handler("RiskEngine.process.endpoint_emulated");
2335        let data_commands = register_data_command_handler("DataEngine.queue_execute.endpoint");
2336        add_instrument_to_cache(&cache, &instrument);
2337        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
2338        let client_order_id = order.client_order_id();
2339        let command = create_submit_order(&instrument, &order);
2340        cache
2341            .borrow_mut()
2342            .add_order(order, None, None, false)
2343            .unwrap();
2344        emulator
2345            .borrow_mut()
2346            .cache_submit_order_command(command.clone());
2347
2348        msgbus::send_trading_command(
2349            MessagingSwitchboard::order_emulator_execute(),
2350            TradingCommand::SubmitOrder(command),
2351        );
2352        let cache = cache.borrow();
2353        let cached_order = cache.order(&client_order_id).unwrap();
2354        let risk_events = risk_events.get_messages();
2355        let data_commands = data_commands.get_messages();
2356
2357        assert_eq!(cached_order.status(), OrderStatus::Emulated);
2358        assert_eq!(risk_events.len(), 1);
2359        assert!(matches!(risk_events[0], OrderEventAny::Emulated(_)));
2360        assert_eq!(data_commands.len(), 1);
2361        assert!(matches!(
2362            &data_commands[0],
2363            DataCommand::Subscribe(SubscribeCommand::Quotes(command))
2364                if command.instrument_ids == [instrument.id()]
2365        ));
2366    }
2367
2368    #[rstest]
2369    fn test_cancel_all_orders_filters_emulated_orders_by_client(instrument: CryptoPerpetual) {
2370        let (_clock, cache, emulator) = create_emulator();
2371        let _risk_events = register_risk_event_handler("RiskEngine.process.cancel_all_client");
2372        let portfolio_events =
2373            register_portfolio_event_handler("Portfolio.update_order.cancel_all_client");
2374        let _data_commands = register_data_command_handler("DataEngine.queue_execute.cancel_all");
2375        add_instrument_to_cache(&cache, &instrument);
2376
2377        let selected_client = ClientId::from("CLIENT-001");
2378        let other_client = ClientId::from("CLIENT-002");
2379        let make_order = |client_order_id| {
2380            OrderTestBuilder::new(OrderType::StopMarket)
2381                .instrument_id(instrument.id())
2382                .client_order_id(client_order_id)
2383                .side(OrderSide::Buy)
2384                .trigger_price(Price::from("5100.00"))
2385                .quantity(Quantity::from(1))
2386                .emulation_trigger(TriggerType::BidAsk)
2387                .build()
2388        };
2389        let selected_order = make_order(ClientOrderId::from("O-EMULATED-SELECTED"));
2390        let other_order = make_order(ClientOrderId::from("O-EMULATED-OTHER"));
2391        let unclaimed_order = make_order(ClientOrderId::from("O-EMULATED-UNCLAIMED"));
2392        let synthetic_formula = format!("{} * 1.0", instrument.id());
2393        let synthetic = SyntheticInstrument::builder()
2394            .symbol(Symbol::from("ETH-INDEX"))
2395            .price_precision(instrument.price_precision())
2396            .components(vec![instrument.id()])
2397            .formula(&synthetic_formula)
2398            .ts_event(0.into())
2399            .ts_init(0.into())
2400            .build()
2401            .unwrap();
2402        let trigger_instrument_id = synthetic.id;
2403        let cross_trigger_order = OrderTestBuilder::new(OrderType::StopMarket)
2404            .instrument_id(instrument.id())
2405            .client_order_id(ClientOrderId::from("O-EMULATED-CROSS-TRIGGER"))
2406            .side(OrderSide::Buy)
2407            .trigger_price(Price::from("5100.00"))
2408            .quantity(Quantity::from(1))
2409            .emulation_trigger(TriggerType::BidAsk)
2410            .trigger_instrument_id(trigger_instrument_id)
2411            .build();
2412        let mut selected_submit = create_submit_order(&instrument, &selected_order);
2413        selected_submit.client_id = Some(selected_client);
2414        let mut other_submit = create_submit_order(&instrument, &other_order);
2415        other_submit.client_id = Some(other_client);
2416        let unclaimed_submit = create_submit_order(&instrument, &unclaimed_order);
2417        let mut cross_trigger_submit = create_submit_order(&instrument, &cross_trigger_order);
2418        cross_trigger_submit.client_id = Some(selected_client);
2419        {
2420            let mut cache = cache.borrow_mut();
2421            cache.add_synthetic(synthetic).unwrap();
2422            cache
2423                .add_order(selected_order.clone(), None, Some(selected_client), false)
2424                .unwrap();
2425            cache
2426                .add_order(other_order.clone(), None, Some(other_client), false)
2427                .unwrap();
2428            cache
2429                .add_order(unclaimed_order.clone(), None, None, false)
2430                .unwrap();
2431            cache
2432                .add_order(
2433                    cross_trigger_order.clone(),
2434                    None,
2435                    Some(selected_client),
2436                    false,
2437                )
2438                .unwrap();
2439        }
2440        emulator.borrow_mut().handle_submit_order(&selected_submit);
2441        emulator.borrow_mut().handle_submit_order(&other_submit);
2442        emulator.borrow_mut().handle_submit_order(&unclaimed_submit);
2443        emulator
2444            .borrow_mut()
2445            .handle_submit_order(&cross_trigger_submit);
2446
2447        emulator
2448            .borrow_mut()
2449            .execute(TradingCommand::CancelAllOrders(CancelAllOrders::new(
2450                TraderId::from("TRADER-001"),
2451                Some(selected_client),
2452                StrategyId::from("CALLER-001"),
2453                trigger_instrument_id,
2454                None,
2455                UUID4::new(),
2456                0.into(),
2457                None,
2458                None,
2459            )));
2460
2461        assert_eq!(
2462            cache
2463                .borrow()
2464                .order(&cross_trigger_order.client_order_id())
2465                .unwrap()
2466                .status(),
2467            OrderStatus::Emulated
2468        );
2469
2470        emulator
2471            .borrow_mut()
2472            .execute(TradingCommand::CancelAllOrders(CancelAllOrders::new(
2473                TraderId::from("TRADER-001"),
2474                Some(selected_client),
2475                StrategyId::from("CALLER-001"),
2476                instrument.id(),
2477                None,
2478                UUID4::new(),
2479                0.into(),
2480                None,
2481                None,
2482            )));
2483
2484        let cache = cache.borrow();
2485        assert_eq!(
2486            cache
2487                .order(&selected_order.client_order_id())
2488                .unwrap()
2489                .status(),
2490            OrderStatus::Canceled
2491        );
2492        assert_eq!(
2493            cache
2494                .order(&other_order.client_order_id())
2495                .unwrap()
2496                .status(),
2497            OrderStatus::Emulated
2498        );
2499        assert_eq!(
2500            cache
2501                .order(&unclaimed_order.client_order_id())
2502                .unwrap()
2503                .status(),
2504            OrderStatus::Emulated
2505        );
2506        assert_eq!(
2507            cache
2508                .order(&cross_trigger_order.client_order_id())
2509                .unwrap()
2510                .status(),
2511            OrderStatus::Canceled
2512        );
2513        let portfolio_events = portfolio_events.get_messages();
2514        assert_eq!(portfolio_events.len(), 2);
2515        let canceled_ids: AHashSet<_> = portfolio_events
2516            .iter()
2517            .filter_map(|event| match event {
2518                OrderEventAny::Canceled(event) => Some(event.client_order_id),
2519                _ => None,
2520            })
2521            .collect();
2522        assert_eq!(
2523            canceled_ids,
2524            AHashSet::from_iter([
2525                selected_order.client_order_id(),
2526                cross_trigger_order.client_order_id(),
2527            ])
2528        );
2529    }
2530
2531    #[rstest]
2532    fn test_dispatch_manager_submit_to_risk_uses_risk_queue(instrument: CryptoPerpetual) {
2533        let (_clock, _cache, emulator) = create_emulator();
2534        let (handler, messages): (_, TypedIntoMessageSavingHandler<TradingCommand>) =
2535            get_typed_into_message_saving_handler(Some(Ustr::from("RiskEngine.queue_execute")));
2536        msgbus::register_trading_command_endpoint(
2537            MessagingSwitchboard::risk_engine_queue_execute(),
2538            handler,
2539        );
2540        let order = create_stop_market_order(&instrument, TriggerType::Default);
2541        let command = create_submit_order(&instrument, &order);
2542        let client_order_id = command.client_order_id;
2543
2544        emulator
2545            .borrow_mut()
2546            .dispatch_manager_action(OrderManagerAction::SubmitToRisk(command));
2547
2548        let messages = messages.get_messages();
2549        assert_eq!(messages.len(), 1);
2550        assert!(matches!(
2551            messages.first(),
2552            Some(TradingCommand::SubmitOrder(command))
2553                if command.client_order_id == client_order_id
2554        ));
2555    }
2556
2557    #[rstest]
2558    fn test_dispatch_manager_submit_to_algorithm_uses_dynamic_endpoint(
2559        instrument: CryptoPerpetual,
2560    ) {
2561        let (_clock, _cache, emulator) = create_emulator();
2562        let exec_algorithm_id = ExecAlgorithmId::from("ALG-001");
2563        let endpoint = format!("{exec_algorithm_id}.execute");
2564        let (handler, messages) =
2565            get_any_saving_handler::<TradingCommand>(Some(Ustr::from("ALG-001.execute")));
2566        msgbus::register_any(endpoint.into(), handler);
2567        let order = create_stop_market_order(&instrument, TriggerType::Default);
2568        let command = create_submit_order(&instrument, &order);
2569        let client_order_id = command.client_order_id;
2570
2571        emulator
2572            .borrow_mut()
2573            .dispatch_manager_action(OrderManagerAction::SubmitToAlgorithm {
2574                command,
2575                exec_algorithm_id,
2576            });
2577
2578        let messages = messages.get_messages();
2579        assert_eq!(messages.len(), 1);
2580        assert!(matches!(
2581            messages.first(),
2582            Some(TradingCommand::SubmitOrder(command))
2583                if command.client_order_id == client_order_id
2584        ));
2585    }
2586
2587    #[rstest]
2588    fn test_dispatch_manager_cancel_local_applies_and_publishes_event(instrument: CryptoPerpetual) {
2589        let (_clock, cache, emulator) = create_emulator();
2590        let portfolio_events =
2591            register_portfolio_event_handler("Portfolio.update_order.dispatch_canceled");
2592        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
2593        let client_order_id = order.client_order_id();
2594        let strategy_id = order.strategy_id();
2595        let instrument_id = order.instrument_id();
2596        let command = create_submit_order(&instrument, &order);
2597        let (order_handler, order_events) = subscribe_order_topic(strategy_id);
2598        let (cancel_handler, cancel_events) = subscribe_order_cancel_topic(instrument_id);
2599        cache
2600            .borrow_mut()
2601            .add_order(order.clone(), None, None, false)
2602            .unwrap();
2603        emulator.borrow_mut().cache_submit_order_command(command);
2604
2605        emulator
2606            .borrow_mut()
2607            .dispatch_manager_action(OrderManagerAction::CancelLocal(order));
2608        msgbus::unsubscribe_order_events(get_event_order_topic(strategy_id).into(), &order_handler);
2609        msgbus::unsubscribe_order_events(
2610            get_order_canceled_topic(instrument_id).into(),
2611            &cancel_handler,
2612        );
2613        let cached_order = cache
2614            .borrow()
2615            .order(&client_order_id)
2616            .map(|order| order.clone())
2617            .unwrap();
2618        let portfolio_events = portfolio_events.get_messages();
2619        let order_events = order_events.borrow();
2620        let cancel_events = cancel_events.borrow();
2621        let commands = emulator.borrow().get_submit_order_commands();
2622
2623        assert_eq!(cached_order.status(), OrderStatus::Canceled);
2624        assert_eq!(portfolio_events.len(), 1);
2625        assert_eq!(order_events.len(), 1);
2626        assert_eq!(cancel_events.len(), 1);
2627        assert!(matches!(
2628            &portfolio_events[0],
2629            OrderEventAny::Canceled(event) if event.client_order_id == client_order_id
2630        ));
2631        assert_eq!(order_events[0].client_order_id(), client_order_id);
2632        assert_eq!(cancel_events[0].client_order_id(), client_order_id);
2633        assert!(!commands.contains_key(&client_order_id));
2634    }
2635
2636    #[rstest]
2637    fn test_dispatch_manager_modify_local_quantity_updates_order(instrument: CryptoPerpetual) {
2638        let (_clock, cache, emulator) = create_emulator();
2639        let risk_events = register_risk_event_handler("RiskEngine.process.dispatch_updated");
2640        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
2641        let client_order_id = order.client_order_id();
2642        let quantity = Quantity::from(2);
2643        cache
2644            .borrow_mut()
2645            .add_order(order.clone(), None, None, false)
2646            .unwrap();
2647
2648        emulator
2649            .borrow_mut()
2650            .dispatch_manager_action(OrderManagerAction::ModifyLocalQuantity { order, quantity });
2651        let cache = cache.borrow();
2652        let cached_order = cache.order(&client_order_id).unwrap();
2653        let risk_events = risk_events.get_messages();
2654
2655        assert_eq!(cached_order.quantity(), quantity);
2656        assert_eq!(risk_events.len(), 1);
2657        assert!(matches!(
2658            &risk_events[0],
2659            OrderEventAny::Updated(event) if event.client_order_id == client_order_id
2660        ));
2661    }
2662
2663    #[rstest]
2664    fn test_subscribed_quotes_initially_empty() {
2665        let (_clock, _cache, emulator) = create_emulator();
2666
2667        assert!(emulator.borrow().subscribed_quotes().is_empty());
2668    }
2669
2670    #[rstest]
2671    fn test_subscribed_trades_initially_empty() {
2672        let (_clock, _cache, emulator) = create_emulator();
2673
2674        assert!(emulator.borrow().subscribed_trades().is_empty());
2675    }
2676
2677    #[rstest]
2678    fn test_get_submit_order_commands_initially_empty() {
2679        let (_clock, _cache, emulator) = create_emulator();
2680
2681        assert!(emulator.borrow().get_submit_order_commands().is_empty());
2682    }
2683
2684    #[rstest]
2685    fn test_get_matching_core_returns_none_when_not_created(instrument: CryptoPerpetual) {
2686        let (_clock, _cache, emulator) = create_emulator();
2687
2688        assert!(
2689            emulator
2690                .borrow()
2691                .get_matching_core(&instrument.id())
2692                .is_none()
2693        );
2694    }
2695
2696    #[rstest]
2697    fn test_create_matching_core(instrument: CryptoPerpetual) {
2698        let (_clock, cache, emulator) = create_emulator();
2699        add_instrument_to_cache(&cache, &instrument);
2700
2701        emulator
2702            .borrow_mut()
2703            .get_or_create_matching_core(instrument.id(), TriggerType::BidAsk)
2704            .unwrap();
2705
2706        assert!(
2707            emulator
2708                .borrow()
2709                .get_matching_core(&instrument.id())
2710                .is_some()
2711        );
2712    }
2713
2714    #[rstest]
2715    fn test_on_quote_tick_no_matching_core_does_not_panic(instrument: CryptoPerpetual) {
2716        let (_clock, _cache, emulator) = create_emulator();
2717        let quote = create_quote_tick(&instrument, "5060.00", "5070.00");
2718
2719        emulator.borrow_mut().on_quote_tick(quote);
2720    }
2721
2722    #[rstest]
2723    fn test_on_trade_tick_no_matching_core_does_not_panic(instrument: CryptoPerpetual) {
2724        let (_clock, _cache, emulator) = create_emulator();
2725        let trade = create_trade_tick(&instrument, "5065.00");
2726
2727        emulator.borrow_mut().on_trade_tick(trade);
2728    }
2729
2730    #[rstest]
2731    fn test_submit_order_bid_ask_trigger_creates_matching_core(instrument: CryptoPerpetual) {
2732        let (_clock, cache, emulator) = create_emulator();
2733        add_instrument_to_cache(&cache, &instrument);
2734        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
2735        let command = create_submit_order(&instrument, &order);
2736        cache
2737            .borrow_mut()
2738            .add_order(order, None, None, false)
2739            .unwrap();
2740
2741        emulator
2742            .borrow_mut()
2743            .cache_submit_order_command(command.clone());
2744        emulator.borrow_mut().handle_submit_order(&command);
2745
2746        assert!(
2747            emulator
2748                .borrow()
2749                .get_matching_core(&instrument.id())
2750                .is_some()
2751        );
2752    }
2753
2754    #[rstest]
2755    fn test_submit_order_bid_ask_trigger_tracks_quote_subscription(instrument: CryptoPerpetual) {
2756        let (_clock, cache, emulator) = create_emulator();
2757        let data_commands = register_data_command_handler("DataEngine.queue_execute.quotes");
2758        add_instrument_to_cache(&cache, &instrument);
2759        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
2760        let command = create_submit_order(&instrument, &order);
2761        cache
2762            .borrow_mut()
2763            .add_order(order, None, None, false)
2764            .unwrap();
2765
2766        emulator
2767            .borrow_mut()
2768            .cache_submit_order_command(command.clone());
2769        emulator.borrow_mut().handle_submit_order(&command);
2770
2771        assert_eq!(emulator.borrow().subscribed_quotes(), vec![instrument.id()]);
2772        assert!(emulator.borrow().subscribed_trades().is_empty());
2773
2774        let commands = data_commands.get_messages();
2775        assert_eq!(commands.len(), 1);
2776        assert!(matches!(
2777            &commands[0],
2778            DataCommand::Subscribe(SubscribeCommand::Quotes(command))
2779                if command.instrument_ids == [instrument.id()]
2780        ));
2781
2782        let quote = create_quote_tick(&instrument, "5060.00", "5070.00");
2783        msgbus::publish_quote(get_quotes_topic(instrument.id()), &quote);
2784        let core = emulator
2785            .borrow()
2786            .get_matching_core(&instrument.id())
2787            .unwrap();
2788        assert_eq!(core.bid, Some(Price::from("5060.00")));
2789        assert_eq!(core.ask, Some(Price::from("5070.00")));
2790    }
2791
2792    #[rstest]
2793    fn test_submit_order_last_price_trigger_tracks_trade_subscription(instrument: CryptoPerpetual) {
2794        let (_clock, cache, emulator) = create_emulator();
2795        let data_commands = register_data_command_handler("DataEngine.queue_execute.trades");
2796        add_instrument_to_cache(&cache, &instrument);
2797        let order = create_stop_market_order(&instrument, TriggerType::LastPrice);
2798        let command = create_submit_order(&instrument, &order);
2799        cache
2800            .borrow_mut()
2801            .add_order(order, None, None, false)
2802            .unwrap();
2803
2804        emulator
2805            .borrow_mut()
2806            .cache_submit_order_command(command.clone());
2807        emulator.borrow_mut().handle_submit_order(&command);
2808
2809        assert!(emulator.borrow().subscribed_quotes().is_empty());
2810        assert_eq!(emulator.borrow().subscribed_trades(), vec![instrument.id()]);
2811
2812        let commands = data_commands.get_messages();
2813        assert_eq!(commands.len(), 1);
2814        assert!(matches!(
2815            &commands[0],
2816            DataCommand::Subscribe(SubscribeCommand::Trades(command))
2817                if command.instrument_ids == [instrument.id()]
2818        ));
2819
2820        let trade = create_trade_tick(&instrument, "5065.00");
2821        msgbus::publish_trade(get_trades_topic(instrument.id()), &trade);
2822        let core = emulator
2823            .borrow()
2824            .get_matching_core(&instrument.id())
2825            .unwrap();
2826        assert_eq!(core.last, Some(Price::from("5065.00")));
2827    }
2828
2829    #[rstest]
2830    #[case(TriggerType::Default)]
2831    #[case(TriggerType::BidAsk)]
2832    #[case(TriggerType::LastPrice)]
2833    fn test_subscriptions_retry_after_handler_registration_without_duplicates(
2834        instrument: CryptoPerpetual,
2835        #[case] emulation_trigger: TriggerType,
2836    ) {
2837        let clock = Rc::new(RefCell::new(VirtualClock::new()));
2838        let cache = Rc::new(RefCell::new(Cache::default()));
2839        let emulator = Rc::new(RefCell::new(OrderEmulator::new(clock, cache.clone())));
2840        let data_commands = register_data_command_handler("DataEngine.queue_execute.retry");
2841        add_instrument_to_cache(&cache, &instrument);
2842
2843        for i in 0..3 {
2844            if i == 1 {
2845                OrderEmulator::register_msgbus_handlers(&emulator);
2846            }
2847
2848            let order = OrderTestBuilder::new(OrderType::StopMarket)
2849                .instrument_id(instrument.id())
2850                .client_order_id(ClientOrderId::from(format!("O-SUBSCRIBE-{i}")))
2851                .side(OrderSide::Buy)
2852                .trigger_price(Price::from("5100.00"))
2853                .quantity(Quantity::from(1))
2854                .emulation_trigger(emulation_trigger)
2855                .build();
2856            submit_to_emulator(&cache, &emulator, &instrument, &order);
2857
2858            let expected = if i == 0 {
2859                Vec::new()
2860            } else {
2861                vec![instrument.id()]
2862            };
2863
2864            let emulator = emulator.borrow();
2865
2866            if emulation_trigger == TriggerType::LastPrice {
2867                assert_eq!(emulator.subscribed_trades(), expected);
2868                assert_eq!(emulator.subscribed_quotes(), Vec::new());
2869            } else {
2870                assert_eq!(emulator.subscribed_quotes(), expected);
2871                assert_eq!(emulator.subscribed_trades(), Vec::new());
2872            }
2873
2874            assert_eq!(data_commands.get_messages().len(), usize::from(i != 0));
2875        }
2876
2877        let quote = create_quote_tick(&instrument, "5000.00", "5001.00");
2878        let trade = create_trade_tick(&instrument, "4999.00");
2879        msgbus::publish_quote(get_quotes_topic(instrument.id()), &quote);
2880        msgbus::publish_trade(get_trades_topic(instrument.id()), &trade);
2881        let core = emulator
2882            .borrow()
2883            .get_matching_core(&instrument.id())
2884            .unwrap();
2885
2886        if emulation_trigger == TriggerType::LastPrice {
2887            assert_eq!(core.bid, None);
2888            assert_eq!(core.ask, None);
2889            assert_eq!(core.last, Some(trade.price));
2890        } else {
2891            assert_eq!(core.bid, Some(quote.bid_price));
2892            assert_eq!(core.ask, Some(quote.ask_price));
2893            assert_eq!(core.last, None);
2894        }
2895    }
2896
2897    #[rstest]
2898    fn test_reset_unsubscribes_market_data_and_clears_state(
2899        instrument: CryptoPerpetual,
2900        #[values(false, true)] reregister: bool,
2901    ) {
2902        let (_clock, cache, emulator) = create_emulator();
2903        let data_commands = register_data_command_handler("DataEngine.queue_execute.reset");
2904        add_instrument_to_cache(&cache, &instrument);
2905        let quote_order = create_stop_market_order(&instrument, TriggerType::BidAsk);
2906        let mut quote_command = create_submit_order(&instrument, &quote_order);
2907        quote_command.position_id = Some(PositionId::from("P-RESET"));
2908        let trade_order = OrderTestBuilder::new(OrderType::StopMarket)
2909            .instrument_id(instrument.id())
2910            .client_order_id(ClientOrderId::from("O-RESET-TRADE"))
2911            .side(OrderSide::Buy)
2912            .trigger_price(Price::from("5100.00"))
2913            .quantity(Quantity::from(1))
2914            .emulation_trigger(TriggerType::LastPrice)
2915            .build();
2916        let mut trade_command = create_submit_order(&instrument, &trade_order);
2917        trade_command.position_id = quote_command.position_id;
2918        cache
2919            .borrow_mut()
2920            .add_order(quote_order, None, None, false)
2921            .unwrap();
2922        cache
2923            .borrow_mut()
2924            .add_order(trade_order, None, None, false)
2925            .unwrap();
2926        emulator
2927            .borrow_mut()
2928            .cache_submit_order_command(quote_command.clone());
2929        emulator.borrow_mut().handle_submit_order(&quote_command);
2930        emulator
2931            .borrow_mut()
2932            .cache_submit_order_command(trade_command.clone());
2933        emulator.borrow_mut().handle_submit_order(&trade_command);
2934        data_commands.clear();
2935
2936        assert_eq!(emulator.borrow().subscribed_strategy_count(), 1);
2937        assert_eq!(emulator.borrow().monitored_position_count(), 1);
2938
2939        if reregister {
2940            OrderEmulator::register_msgbus_handlers(&emulator);
2941        }
2942
2943        emulator.borrow_mut().reset();
2944        let commands = data_commands.get_messages();
2945        let emulator_ref = emulator.borrow();
2946
2947        assert!(emulator_ref.subscribed_quotes().is_empty());
2948        assert!(emulator_ref.subscribed_trades().is_empty());
2949        assert!(emulator_ref.subscribed_strategies.is_empty());
2950        assert!(emulator_ref.monitored_positions.is_empty());
2951        assert!(emulator_ref.quote_handlers.is_empty());
2952        assert!(emulator_ref.trade_handlers.is_empty());
2953        assert!(emulator_ref.get_submit_order_commands().is_empty());
2954        assert!(emulator_ref.get_matching_core(&instrument.id()).is_none());
2955        assert!(commands.iter().any(|command| matches!(
2956            command,
2957            DataCommand::Unsubscribe(UnsubscribeCommand::Quotes(command))
2958                if command.instrument_ids == [instrument.id()]
2959        )));
2960        assert!(commands.iter().any(|command| matches!(
2961            command,
2962            DataCommand::Unsubscribe(UnsubscribeCommand::Trades(command))
2963                if command.instrument_ids == [instrument.id()]
2964        )));
2965
2966        drop(emulator_ref);
2967        emulator
2968            .borrow_mut()
2969            .get_or_create_matching_core(instrument.id(), TriggerType::BidAsk)
2970            .unwrap();
2971        let quote = create_quote_tick(&instrument, "5060.00", "5070.00");
2972        let trade = create_trade_tick(&instrument, "5065.00");
2973        msgbus::publish_quote(get_quotes_topic(instrument.id()), &quote);
2974        msgbus::publish_trade(get_trades_topic(instrument.id()), &trade);
2975        let core = emulator
2976            .borrow()
2977            .get_matching_core(&instrument.id())
2978            .unwrap();
2979        assert_eq!(core.bid, None);
2980        assert_eq!(core.ask, None);
2981        assert_eq!(core.last, None);
2982    }
2983
2984    #[rstest]
2985    fn test_reset_unsubscribes_in_sorted_instrument_order(
2986        instrument: CryptoPerpetual,
2987        #[values(TriggerType::BidAsk, TriggerType::LastPrice)] emulation_trigger: TriggerType,
2988    ) {
2989        let (_clock, cache, emulator) = create_emulator();
2990        let data_commands = register_data_command_handler("DataEngine.queue_execute.reset_order");
2991
2992        // Registered in an order that is neither sorted nor reverse sorted, and five
2993        // entries leave a 1-in-120 chance that AHash order coincides with the expectation.
2994        let ids = [
2995            "SOLUSDT-PERP.BINANCE",
2996            "ADAUSDT-PERP.BINANCE",
2997            "XRPUSDT-PERP.BINANCE",
2998            "BTCUSDT-PERP.BINANCE",
2999            "DOTUSDT-PERP.BINANCE",
3000        ];
3001
3002        for (i, id) in ids.iter().enumerate() {
3003            let mut variant = instrument.clone();
3004            variant.id = InstrumentId::from(*id);
3005            add_instrument_to_cache(&cache, &variant);
3006
3007            let order = OrderTestBuilder::new(OrderType::StopMarket)
3008                .instrument_id(variant.id)
3009                .client_order_id(ClientOrderId::from(format!("O-RESET-{i}").as_str()))
3010                .side(OrderSide::Buy)
3011                .trigger_price(Price::from("5100.00"))
3012                .quantity(Quantity::from(1))
3013                .emulation_trigger(emulation_trigger)
3014                .build();
3015            let command = create_submit_order(&variant, &order);
3016            cache
3017                .borrow_mut()
3018                .add_order(order, None, None, false)
3019                .unwrap();
3020            emulator
3021                .borrow_mut()
3022                .cache_submit_order_command(command.clone());
3023            emulator.borrow_mut().handle_submit_order(&command);
3024        }
3025        data_commands.clear();
3026
3027        emulator.borrow_mut().reset();
3028
3029        let unsubscribed: Vec<InstrumentId> = data_commands
3030            .get_messages()
3031            .iter()
3032            .filter_map(|command| match command {
3033                DataCommand::Unsubscribe(UnsubscribeCommand::Quotes(command))
3034                    if emulation_trigger == TriggerType::BidAsk =>
3035                {
3036                    Some(command.single_instrument_id().unwrap())
3037                }
3038                DataCommand::Unsubscribe(UnsubscribeCommand::Trades(command))
3039                    if emulation_trigger == TriggerType::LastPrice =>
3040                {
3041                    Some(command.single_instrument_id().unwrap())
3042                }
3043                _ => None,
3044            })
3045            .collect();
3046
3047        let mut expected: Vec<InstrumentId> =
3048            ids.iter().map(|id| InstrumentId::from(*id)).collect();
3049        expected.sort();
3050
3051        assert_eq!(unsubscribed, expected);
3052    }
3053
3054    #[rstest]
3055    fn test_submit_order_list_handles_reentrant_order_events(instrument: CryptoPerpetual) {
3056        let (_clock, cache, emulator) = create_emulator();
3057        let data_commands = register_data_command_handler("DataEngine.queue_execute.list");
3058        add_instrument_to_cache(&cache, &instrument);
3059        let order_list_id = OrderListId::from("OL-EMULATOR-001");
3060        let first_order = create_list_stop_market_order(&instrument, "O-LIST-001", order_list_id);
3061        let second_order = create_list_stop_market_order(&instrument, "O-LIST-002", order_list_id);
3062        let orders = vec![first_order.clone(), second_order.clone()];
3063        let order_list = OrderList::from_orders(&orders, 0.into());
3064        let order_inits = orders
3065            .iter()
3066            .map(|order| order.init_event().clone())
3067            .collect();
3068        cache
3069            .borrow_mut()
3070            .add_order(first_order.clone(), None, None, false)
3071            .unwrap();
3072        cache
3073            .borrow_mut()
3074            .add_order(second_order.clone(), None, None, false)
3075            .unwrap();
3076        let command = SubmitOrderList::new(
3077            TraderId::from("TRADER-001"),
3078            None,
3079            StrategyId::from("STRATEGY-001"),
3080            order_list,
3081            order_inits,
3082            None,
3083            None,
3084            None,
3085            UUID4::new(),
3086            0.into(),
3087            None,
3088        );
3089
3090        emulator
3091            .borrow_mut()
3092            .execute(TradingCommand::SubmitOrderList(command));
3093
3094        let commands = data_commands.get_messages();
3095        let cache = cache.borrow();
3096        let first_status = cache
3097            .order(&first_order.client_order_id())
3098            .unwrap()
3099            .status();
3100        let second_status = cache
3101            .order(&second_order.client_order_id())
3102            .unwrap()
3103            .status();
3104        drop(cache);
3105        let emulator = emulator.borrow();
3106
3107        assert_eq!(first_status, OrderStatus::Emulated);
3108        assert_eq!(second_status, OrderStatus::Emulated);
3109        assert!(emulator.get_matching_core(&instrument.id()).is_some());
3110        assert_eq!(emulator.subscribed_quotes(), vec![instrument.id()]);
3111        assert!(commands.iter().any(|command| matches!(
3112            command,
3113            DataCommand::Subscribe(SubscribeCommand::Quotes(command))
3114                if command.instrument_ids == [instrument.id()]
3115        )));
3116    }
3117
3118    #[rstest]
3119    fn test_submit_order_caches_command(instrument: CryptoPerpetual) {
3120        let (_clock, cache, emulator) = create_emulator();
3121        add_instrument_to_cache(&cache, &instrument);
3122        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
3123        let client_order_id = order.client_order_id();
3124        let command = create_submit_order(&instrument, &order);
3125        cache
3126            .borrow_mut()
3127            .add_order(order, None, None, false)
3128            .unwrap();
3129
3130        emulator
3131            .borrow_mut()
3132            .cache_submit_order_command(command.clone());
3133        emulator.borrow_mut().handle_submit_order(&command);
3134
3135        let commands = emulator.borrow().get_submit_order_commands();
3136        assert!(commands.contains_key(&client_order_id));
3137    }
3138
3139    #[rstest]
3140    fn test_handle_submit_order_applies_emulated_event_to_cache(instrument: CryptoPerpetual) {
3141        let (_clock, cache, emulator) = create_emulator();
3142        let risk_events = register_risk_event_handler("RiskEngine.process.emulated");
3143        add_instrument_to_cache(&cache, &instrument);
3144        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
3145        let client_order_id = order.client_order_id();
3146        let strategy_id = order.strategy_id();
3147        let command = create_submit_order(&instrument, &order);
3148        cache
3149            .borrow_mut()
3150            .add_order(order, None, None, false)
3151            .unwrap();
3152        let (order_handler, order_events) = subscribe_order_topic(strategy_id);
3153
3154        emulator
3155            .borrow_mut()
3156            .cache_submit_order_command(command.clone());
3157        emulator.borrow_mut().handle_submit_order(&command);
3158        msgbus::unsubscribe_order_events(
3159            format!("events.order.{strategy_id}").into(),
3160            &order_handler,
3161        );
3162        let cache = cache.borrow();
3163        let cached_order = cache.order(&client_order_id).unwrap();
3164        let risk_events = risk_events.get_messages();
3165        let order_events = order_events.borrow();
3166
3167        assert_eq!(cached_order.status(), OrderStatus::Emulated);
3168        assert_eq!(cached_order.event_count(), 2);
3169        assert_eq!(risk_events.len(), 1);
3170        assert!(matches!(risk_events[0], OrderEventAny::Emulated(_)));
3171        assert_eq!(order_events.len(), 1);
3172        assert!(matches!(order_events[0], OrderEventAny::Emulated(_)));
3173    }
3174
3175    #[rstest]
3176    fn test_submit_order_unsupported_emulation_trigger_cancels_order(instrument: CryptoPerpetual) {
3177        let (_clock, cache, emulator) = create_emulator();
3178        let portfolio_events =
3179            register_portfolio_event_handler("Portfolio.update_order.unsupported_trigger");
3180        add_instrument_to_cache(&cache, &instrument);
3181        let order = create_stop_market_order(&instrument, TriggerType::LastOrBidAsk);
3182        let client_order_id = order.client_order_id();
3183        let strategy_id = order.strategy_id();
3184        let instrument_id = order.instrument_id();
3185        let command = create_submit_order(&instrument, &order);
3186        let (order_handler, order_events) = subscribe_order_topic(strategy_id);
3187        let (cancel_handler, cancel_events) = subscribe_order_cancel_topic(instrument_id);
3188        cache
3189            .borrow_mut()
3190            .add_order(order, None, None, false)
3191            .unwrap();
3192        emulator
3193            .borrow_mut()
3194            .cache_submit_order_command(command.clone());
3195
3196        emulator.borrow_mut().handle_submit_order(&command);
3197        msgbus::unsubscribe_order_events(get_event_order_topic(strategy_id).into(), &order_handler);
3198        msgbus::unsubscribe_order_events(
3199            get_order_canceled_topic(instrument_id).into(),
3200            &cancel_handler,
3201        );
3202        let cache = cache.borrow();
3203        let cached_order = cache.order(&client_order_id).unwrap();
3204        let emulator = emulator.borrow();
3205        let portfolio_events = portfolio_events.get_messages();
3206        let order_events = order_events.borrow();
3207        let cancel_events = cancel_events.borrow();
3208
3209        assert_eq!(cached_order.status(), OrderStatus::Canceled);
3210        assert!(matches!(
3211            cached_order.last_event(),
3212            OrderEventAny::Canceled(event) if event.client_order_id == client_order_id
3213        ));
3214        assert!(
3215            !emulator
3216                .get_submit_order_commands()
3217                .contains_key(&client_order_id)
3218        );
3219        assert!(emulator.get_matching_core(&instrument_id).is_none());
3220        assert!(emulator.subscribed_quotes().is_empty());
3221        assert!(emulator.subscribed_trades().is_empty());
3222        assert_eq!(
3223            portfolio_events.as_slice(),
3224            std::slice::from_ref(cached_order.last_event())
3225        );
3226        assert_eq!(
3227            order_events.as_slice(),
3228            std::slice::from_ref(cached_order.last_event())
3229        );
3230        assert_eq!(
3231            cancel_events.as_slice(),
3232            std::slice::from_ref(cached_order.last_event())
3233        );
3234    }
3235
3236    #[rstest]
3237    fn test_submit_order_missing_trigger_instrument_cancels_order(
3238        instrument: CryptoPerpetual,
3239        #[values(false, true)] synthetic: bool,
3240    ) {
3241        let (_clock, cache, emulator) = create_emulator();
3242        add_instrument_to_cache(&cache, &instrument);
3243
3244        let trigger_instrument_id = if synthetic {
3245            InstrumentId::from("BTC-ETH-INDEX.SYNTH")
3246        } else {
3247            InstrumentId::from("BTCUSDT-PERP.BINANCE")
3248        };
3249
3250        let order = OrderTestBuilder::new(OrderType::StopMarket)
3251            .instrument_id(instrument.id())
3252            .side(OrderSide::Buy)
3253            .trigger_price(Price::from("5100.00"))
3254            .quantity(Quantity::from(1))
3255            .emulation_trigger(TriggerType::BidAsk)
3256            .trigger_instrument_id(trigger_instrument_id)
3257            .build();
3258        let client_order_id = order.client_order_id();
3259        let command = create_submit_order(&instrument, &order);
3260        cache
3261            .borrow_mut()
3262            .add_order(order, None, None, false)
3263            .unwrap();
3264
3265        emulator
3266            .borrow_mut()
3267            .cache_submit_order_command(command.clone());
3268        emulator.borrow_mut().handle_submit_order(&command);
3269
3270        let cache = cache.borrow();
3271        let cached_order = cache.order(&client_order_id).unwrap();
3272        let emulator = emulator.borrow();
3273        let commands = emulator.get_submit_order_commands();
3274
3275        assert_eq!(cached_order.status(), OrderStatus::Canceled);
3276        assert!(emulator.get_matching_core(&trigger_instrument_id).is_none());
3277        assert!(emulator.subscribed_quotes().is_empty());
3278        assert!(emulator.subscribed_trades().is_empty());
3279        assert!(!commands.contains_key(&client_order_id));
3280    }
3281
3282    #[rstest]
3283    fn test_submit_order_releases_when_immediately_triggered(instrument: CryptoPerpetual) {
3284        let (_clock, cache, emulator) = create_emulator();
3285        let risk_events =
3286            register_risk_event_handler("RiskEngine.process.submit_immediately_triggered");
3287        add_instrument_to_cache(&cache, &instrument);
3288        let mut core = OrderMatchingCore::new(instrument.id(), instrument.price_increment());
3289        core.set_bid_raw(Price::from("5099.00"));
3290        core.set_ask_raw(Price::from("5101.00"));
3291        emulator
3292            .borrow_mut()
3293            .matching_cores
3294            .insert(instrument.id(), core);
3295        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
3296        let client_order_id = order.client_order_id();
3297        let command = create_submit_order(&instrument, &order);
3298        cache
3299            .borrow_mut()
3300            .add_order(order, None, None, false)
3301            .unwrap();
3302
3303        emulator.borrow_mut().handle_submit_order(&command);
3304
3305        let cache = cache.borrow();
3306        let cached_order = cache.order(&client_order_id).unwrap();
3307        let emulator = emulator.borrow();
3308        let matching_core = emulator.get_matching_core(&instrument.id()).unwrap();
3309        let risk_events = risk_events.get_messages();
3310        assert_eq!(cached_order.status(), OrderStatus::Released);
3311        assert_eq!(cached_order.order_type(), OrderType::Market);
3312        assert!(!matching_core.order_exists(client_order_id));
3313        assert_eq!(emulator.subscribed_strategy_count(), 1);
3314        assert!(
3315            !emulator
3316                .get_submit_order_commands()
3317                .contains_key(&client_order_id)
3318        );
3319        assert_eq!(risk_events.len(), 1);
3320        assert!(matches!(
3321            &risk_events[0],
3322            OrderEventAny::Released(event) if event.client_order_id == client_order_id
3323        ));
3324    }
3325
3326    #[rstest]
3327    #[case::bid_ask_quote_below(TriggerType::BidAsk, Some(("5098.00", "5099.00")), Some("5101.00"), (Some(false), Some(true)))]
3328    #[case::bid_ask_quote_above(TriggerType::BidAsk, Some(("5101.00", "5102.00")), Some("5099.00"), (Some(true), Some(false)))]
3329    #[case::default_quote(TriggerType::Default, Some(("5098.00", "5099.00")), Some("5101.00"), (Some(false), Some(true)))]
3330    #[case::last_price_trade_below(TriggerType::LastPrice, Some(("5101.00", "5102.00")), Some("5099.00"), (Some(false), Some(true)))]
3331    #[case::last_price_trade_above(TriggerType::LastPrice, Some(("5098.00", "5099.00")), Some("5101.00"), (Some(true), Some(false)))]
3332    #[case::last_price_quote_only(TriggerType::LastPrice, Some(("5098.00", "5099.00")), None, (None, None))]
3333    #[case::last_price_trade_only(
3334        TriggerType::LastPrice,
3335        None,
3336        Some("5101.00"),
3337        (Some(true), Some(false))
3338    )]
3339    #[case::bid_ask_trade_only(TriggerType::BidAsk, None, Some("5101.00"), (None, None))]
3340    #[case::default_trade_only(TriggerType::Default, None, Some("5101.00"), (None, None))]
3341    #[case::bid_ask_no_data(TriggerType::BidAsk, None, None, (None, None))]
3342    #[case::default_no_data(TriggerType::Default, None, None, (None, None))]
3343    #[case::last_price_no_data(TriggerType::LastPrice, None, None, (None, None))]
3344    fn test_submit_order_uses_cached_emulation_source(
3345        instrument: CryptoPerpetual,
3346        #[case] emulation_trigger: TriggerType,
3347        #[case] quote: Option<(&str, &str)>,
3348        #[case] trade: Option<&str>,
3349        #[case] stop_matches: (Option<bool>, Option<bool>),
3350        #[values(
3351            OrderType::Limit,
3352            OrderType::StopMarket,
3353            OrderType::StopLimit,
3354            OrderType::MarketIfTouched,
3355            OrderType::LimitIfTouched
3356        )]
3357        order_type: OrderType,
3358        #[values(OrderSide::Buy, OrderSide::Sell)] side: OrderSide,
3359    ) {
3360        let (_clock, cache, emulator) = create_emulator();
3361        let risk_events = register_risk_event_handler("RiskEngine.process.submit_cached_source");
3362        add_instrument_to_cache(&cache, &instrument);
3363        if let Some((bid, ask)) = quote {
3364            cache
3365                .borrow_mut()
3366                .add_quote(create_quote_tick(&instrument, bid, ask))
3367                .unwrap();
3368        }
3369
3370        if let Some(price) = trade {
3371            cache
3372                .borrow_mut()
3373                .add_trade(create_trade_tick(&instrument, price))
3374                .unwrap();
3375        }
3376
3377        let order = OrderTestBuilder::new(order_type)
3378            .instrument_id(instrument.id())
3379            .side(side)
3380            .price(Price::from("5100.00"))
3381            .trigger_price(Price::from("5100.00"))
3382            .quantity(Quantity::from(3))
3383            .emulation_trigger(emulation_trigger)
3384            .build();
3385        let client_order_id = order.client_order_id();
3386        let command = create_submit_order(&instrument, &order);
3387        cache
3388            .borrow_mut()
3389            .add_order(order, None, None, false)
3390            .unwrap();
3391
3392        emulator.borrow_mut().handle_submit_order(&command);
3393
3394        let stop_matches = match side {
3395            OrderSide::Buy => stop_matches.0,
3396            OrderSide::Sell => stop_matches.1,
3397        };
3398
3399        let should_release = stop_matches.is_some_and(|matches| match order_type {
3400            OrderType::StopMarket | OrderType::StopLimit => matches,
3401            _ => !matches,
3402        });
3403
3404        let expected_status = if should_release {
3405            OrderStatus::Released
3406        } else {
3407            OrderStatus::Emulated
3408        };
3409
3410        let expected_type = if should_release {
3411            match order_type {
3412                OrderType::StopLimit | OrderType::LimitIfTouched => OrderType::Limit,
3413                _ => OrderType::Market,
3414            }
3415        } else {
3416            order_type
3417        };
3418
3419        let cache = cache.borrow();
3420        let cached_order = cache.order(&client_order_id).unwrap();
3421        let emulator = emulator.borrow();
3422        let core = emulator.get_matching_core(&instrument.id()).unwrap();
3423        let events = risk_events.get_messages();
3424        assert_eq!(cached_order.status(), expected_status);
3425        assert_eq!(cached_order.order_type(), expected_type);
3426        assert_eq!(cached_order.quantity(), Quantity::from(3));
3427        assert_eq!(core.order_exists(client_order_id), !should_release);
3428        assert_eq!(
3429            emulator
3430                .get_submit_order_commands()
3431                .contains_key(&client_order_id),
3432            !should_release
3433        );
3434        assert_eq!(events.len(), 1);
3435        assert_eq!(events[0].client_order_id(), client_order_id);
3436        assert_eq!(
3437            matches!(&events[0], OrderEventAny::Released(_)),
3438            should_release
3439        );
3440        assert_eq!(
3441            matches!(&events[0], OrderEventAny::Emulated(_)),
3442            !should_release
3443        );
3444
3445        let expected_price = match (emulation_trigger, side) {
3446            (TriggerType::LastPrice, _) => trade.map(Price::from),
3447            (_, OrderSide::Buy) => quote.map(|(_, ask)| Price::from(ask)),
3448            (_, OrderSide::Sell) => quote.map(|(bid, _)| Price::from(bid)),
3449        };
3450
3451        let released_price = match &events[0] {
3452            OrderEventAny::Released(event) => Some(event.released_price),
3453            _ => None,
3454        };
3455
3456        assert_eq!(released_price, expected_price.filter(|_| should_release));
3457    }
3458
3459    #[rstest]
3460    #[case(TriggerType::Default, Some("5099.00"), Some("5101.00"), None)]
3461    #[case(TriggerType::BidAsk, Some("5099.00"), Some("5101.00"), None)]
3462    #[case(TriggerType::LastPrice, None, None, Some("5098.00"))]
3463    fn test_create_matching_core_seeds_cached_prices(
3464        instrument: CryptoPerpetual,
3465        #[case] emulation_trigger: TriggerType,
3466        #[case] expected_bid: Option<&str>,
3467        #[case] expected_ask: Option<&str>,
3468        #[case] expected_last: Option<&str>,
3469    ) {
3470        let (_clock, cache, emulator) = create_emulator();
3471        add_instrument_to_cache(&cache, &instrument);
3472        cache
3473            .borrow_mut()
3474            .add_quote(create_quote_tick(&instrument, "5099.00", "5101.00"))
3475            .unwrap();
3476        cache
3477            .borrow_mut()
3478            .add_trade(create_trade_tick(&instrument, "5098.00"))
3479            .unwrap();
3480
3481        let core = emulator
3482            .borrow_mut()
3483            .get_or_create_matching_core(instrument.id(), emulation_trigger)
3484            .unwrap();
3485
3486        let emulator = emulator.borrow();
3487        let stored_core = emulator.get_matching_core(&instrument.id()).unwrap();
3488        assert_eq!(core.bid, expected_bid.map(Price::from));
3489        assert_eq!(core.ask, expected_ask.map(Price::from));
3490        assert_eq!(core.last, expected_last.map(Price::from));
3491        assert_eq!(stored_core.bid, core.bid);
3492        assert_eq!(stored_core.ask, core.ask);
3493        assert_eq!(stored_core.last, core.last);
3494    }
3495
3496    #[rstest]
3497    fn test_submit_order_seeds_cached_trigger_instrument(
3498        instrument: CryptoPerpetual,
3499        #[values(TriggerType::BidAsk, TriggerType::LastPrice)] emulation_trigger: TriggerType,
3500    ) {
3501        let (_clock, cache, emulator) = create_emulator();
3502        let _risk_events =
3503            register_risk_event_handler("RiskEngine.process.cached_trigger_instrument");
3504        let trigger_instrument = btcusd_bybit();
3505        add_instrument_to_cache(&cache, &instrument);
3506        add_instrument_to_cache(&cache, &trigger_instrument);
3507        cache
3508            .borrow_mut()
3509            .add_quote(create_quote_tick(&instrument, "5099.00", "5101.00"))
3510            .unwrap();
3511        cache
3512            .borrow_mut()
3513            .add_trade(create_trade_tick(&instrument, "5101.00"))
3514            .unwrap();
3515        cache
3516            .borrow_mut()
3517            .add_quote(create_quote_tick(&trigger_instrument, "5098.00", "5099.00"))
3518            .unwrap();
3519        cache
3520            .borrow_mut()
3521            .add_trade(create_trade_tick(&trigger_instrument, "5099.00"))
3522            .unwrap();
3523        let order = OrderTestBuilder::new(OrderType::StopMarket)
3524            .instrument_id(instrument.id())
3525            .trigger_instrument_id(trigger_instrument.id())
3526            .side(OrderSide::Buy)
3527            .trigger_price(Price::from("5100.00"))
3528            .quantity(Quantity::from(1))
3529            .emulation_trigger(emulation_trigger)
3530            .build();
3531        let client_order_id = order.client_order_id();
3532        let command = create_submit_order(&instrument, &order);
3533        cache
3534            .borrow_mut()
3535            .add_order(order, None, None, false)
3536            .unwrap();
3537
3538        emulator.borrow_mut().handle_submit_order(&command);
3539
3540        let emulator = emulator.borrow();
3541        let core = emulator
3542            .get_matching_core(&trigger_instrument.id())
3543            .unwrap();
3544
3545        let uses_quotes = emulation_trigger != TriggerType::LastPrice;
3546        assert_eq!(core.bid, uses_quotes.then(|| Price::from("5098.00")));
3547        assert_eq!(core.ask, uses_quotes.then(|| Price::from("5099.00")));
3548        assert_eq!(
3549            core.last,
3550            (emulation_trigger == TriggerType::LastPrice).then(|| Price::from("5099.00"))
3551        );
3552        assert_eq!(
3553            cache.borrow().order(&client_order_id).unwrap().status(),
3554            OrderStatus::Emulated
3555        );
3556        assert!(emulator.get_matching_core(&instrument.id()).is_none());
3557    }
3558
3559    #[rstest]
3560    fn test_quote_emulated_trailing_stop_uses_latest_cached_trade(
3561        instrument: CryptoPerpetual,
3562        #[values(TriggerType::Default, TriggerType::BidAsk)] emulation_trigger: TriggerType,
3563        #[values(TriggerType::LastPrice, TriggerType::LastOrBidAsk)] trigger_type: TriggerType,
3564    ) {
3565        let (_clock, cache, emulator) = create_emulator();
3566        let _risk_events = register_risk_event_handler("RiskEngine.process.cached_trailing_trade");
3567        add_instrument_to_cache(&cache, &instrument);
3568        cache
3569            .borrow_mut()
3570            .add_quote(create_quote_tick(&instrument, "5000.00", "5001.00"))
3571            .unwrap();
3572        cache
3573            .borrow_mut()
3574            .add_trade(create_trade_tick(&instrument, "5000.00"))
3575            .unwrap();
3576        let order = OrderTestBuilder::new(OrderType::TrailingStopMarket)
3577            .instrument_id(instrument.id())
3578            .side(OrderSide::Sell)
3579            .quantity(Quantity::from(3))
3580            .trigger_type(trigger_type)
3581            .trailing_offset(dec!(10))
3582            .trailing_offset_type(TrailingOffsetType::Price)
3583            .emulation_trigger(emulation_trigger)
3584            .build();
3585        let client_order_id = order.client_order_id();
3586        let command = create_submit_order(&instrument, &order);
3587        cache
3588            .borrow_mut()
3589            .add_order(order, None, None, false)
3590            .unwrap();
3591
3592        emulator.borrow_mut().handle_submit_order(&command);
3593
3594        assert_eq!(
3595            cache
3596                .borrow()
3597                .order(&client_order_id)
3598                .unwrap()
3599                .trigger_price(),
3600            Some(Price::from("4990.00"))
3601        );
3602
3603        cache
3604            .borrow_mut()
3605            .add_trade(create_trade_tick(&instrument, "5050.00"))
3606            .unwrap();
3607        emulator
3608            .borrow_mut()
3609            .on_quote_tick(create_quote_tick(&instrument, "5010.00", "5011.00"));
3610
3611        let cache = cache.borrow();
3612        let order = cache.order(&client_order_id).unwrap();
3613        assert_eq!(order.trigger_price(), Some(Price::from("5040.00")));
3614        assert_eq!(order.quantity(), Quantity::from(3));
3615        assert_eq!(order.status(), OrderStatus::Emulated);
3616    }
3617
3618    #[rstest]
3619    #[case(TriggerType::LastPrice, TriggerType::BidAsk)]
3620    #[case(TriggerType::LastPrice, TriggerType::Default)]
3621    #[case(TriggerType::BidAsk, TriggerType::LastPrice)]
3622    #[case(TriggerType::Default, TriggerType::LastPrice)]
3623    fn test_submit_order_uses_mixed_cached_sources(
3624        instrument: CryptoPerpetual,
3625        #[case] first_source: TriggerType,
3626        #[case] second_source: TriggerType,
3627        #[values(Some(("5098.00", "5099.00")), Some(("5101.00", "5102.00")), None)] quote: Option<
3628            (&str, &str),
3629        >,
3630        #[values(Some("5099.00"), Some("5101.00"), None)] trade: Option<&str>,
3631        #[values(
3632            OrderType::Limit,
3633            OrderType::StopMarket,
3634            OrderType::StopLimit,
3635            OrderType::MarketIfTouched,
3636            OrderType::LimitIfTouched
3637        )]
3638        order_type: OrderType,
3639        #[values(OrderSide::Buy, OrderSide::Sell)] side: OrderSide,
3640    ) {
3641        let (_clock, cache, emulator) = create_emulator();
3642        let events = register_risk_event_handler("RiskEngine.process.mixed_cached_sources");
3643        add_instrument_to_cache(&cache, &instrument);
3644        if let Some((bid, ask)) = quote {
3645            cache
3646                .borrow_mut()
3647                .add_quote(create_quote_tick(&instrument, bid, ask))
3648                .unwrap();
3649        }
3650
3651        if let Some(price) = trade {
3652            cache
3653                .borrow_mut()
3654                .add_trade(create_trade_tick(&instrument, price))
3655                .unwrap();
3656        }
3657
3658        let first = OrderTestBuilder::new(OrderType::StopMarket)
3659            .instrument_id(instrument.id())
3660            .client_order_id(ClientOrderId::from("O-MIXED-FIRST"))
3661            .side(side)
3662            .trigger_price(Price::from(if side == OrderSide::Buy {
3663                "6000.00"
3664            } else {
3665                "4000.00"
3666            }))
3667            .quantity(Quantity::from(2))
3668            .emulation_trigger(first_source)
3669            .build();
3670
3671        let second = OrderTestBuilder::new(order_type)
3672            .instrument_id(instrument.id())
3673            .client_order_id(ClientOrderId::from("O-MIXED-SECOND"))
3674            .side(side)
3675            .price(Price::from("5100.00"))
3676            .trigger_price(Price::from("5100.00"))
3677            .quantity(Quantity::from(3))
3678            .emulation_trigger(second_source)
3679            .build();
3680        submit_to_emulator(&cache, &emulator, &instrument, &first);
3681        let first_command = emulator
3682            .borrow()
3683            .get_submit_order_commands()
3684            .get(&first.client_order_id())
3685            .cloned()
3686            .unwrap();
3687        submit_to_emulator(&cache, &emulator, &instrument, &second);
3688
3689        let market_price = if second_source == TriggerType::LastPrice {
3690            trade.map(Price::from)
3691        } else {
3692            quote.map(|(bid, ask)| Price::from(if side == OrderSide::Buy { ask } else { bid }))
3693        };
3694
3695        let released = market_price.is_some_and(|price| {
3696            let stop = matches!(order_type, OrderType::StopMarket | OrderType::StopLimit);
3697            match (side, stop) {
3698                (OrderSide::Buy, true) | (OrderSide::Sell, false) => {
3699                    price >= Price::from("5100.00")
3700                }
3701                _ => price <= Price::from("5100.00"),
3702            }
3703        });
3704
3705        let cache = cache.borrow();
3706        let emulator = emulator.borrow();
3707        let core = emulator.get_matching_core(&instrument.id()).unwrap();
3708        let commands = emulator.get_submit_order_commands();
3709        let first_cached = cache.order(&first.client_order_id()).unwrap();
3710        let second_cached = cache.order(&second.client_order_id()).unwrap();
3711        assert_eq!(first_cached.status(), OrderStatus::Emulated);
3712        assert_eq!(first_cached.quantity(), Quantity::from(2));
3713        assert!(core.order_exists(first.client_order_id()));
3714        assert_eq!(commands.get(&first.client_order_id()), Some(&first_command));
3715        assert_eq!(
3716            second_cached.status(),
3717            if released {
3718                OrderStatus::Released
3719            } else {
3720                OrderStatus::Emulated
3721            }
3722        );
3723        assert_eq!(second_cached.quantity(), Quantity::from(3));
3724        assert_eq!(core.order_exists(second.client_order_id()), !released);
3725        assert_eq!(commands.contains_key(&second.client_order_id()), !released);
3726        assert_eq!(commands.len(), if released { 1 } else { 2 });
3727        assert_eq!(core.bid, quote.map(|(bid, _)| Price::from(bid)));
3728        assert_eq!(core.ask, quote.map(|(_, ask)| Price::from(ask)));
3729        assert_eq!(core.last, trade.map(Price::from));
3730        assert_eq!(emulator.subscribed_quotes(), vec![instrument.id()]);
3731        assert_eq!(emulator.subscribed_trades(), vec![instrument.id()]);
3732        let events = events.get_messages();
3733        assert_eq!(events.len(), 2);
3734
3735        match &events[1] {
3736            OrderEventAny::Released(event) => {
3737                assert!(released);
3738                assert_eq!(event.client_order_id, second.client_order_id());
3739                assert_eq!(event.released_price, market_price.unwrap());
3740            }
3741            OrderEventAny::Emulated(event) => {
3742                assert!(!released);
3743                assert_eq!(event.client_order_id, second.client_order_id());
3744            }
3745            event => panic!("Unexpected event: {event:?}"),
3746        }
3747    }
3748
3749    #[rstest]
3750    fn test_mixed_sources_release_only_on_selected_updates(
3751        instrument: CryptoPerpetual,
3752        #[values(TriggerType::Default, TriggerType::BidAsk)] quote_source: TriggerType,
3753        #[values(
3754            OrderType::Limit,
3755            OrderType::StopMarket,
3756            OrderType::StopLimit,
3757            OrderType::MarketIfTouched,
3758            OrderType::LimitIfTouched
3759        )]
3760        order_type: OrderType,
3761        #[values(OrderSide::Buy, OrderSide::Sell)] side: OrderSide,
3762        #[values(false, true)] trade_first: bool,
3763    ) {
3764        let (_clock, cache, emulator) = create_emulator();
3765        let events = register_risk_event_handler("RiskEngine.process.mixed_updates");
3766        add_instrument_to_cache(&cache, &instrument);
3767        let stop = matches!(order_type, OrderType::StopMarket | OrderType::StopLimit);
3768        let releases_above = (side == OrderSide::Buy) == stop;
3769
3770        let (holding_bid, holding_ask, holding_trade, release_bid, release_ask, release_trade) =
3771            if releases_above {
3772                (
3773                    "5097.00", "5098.00", "5099.00", "5102.00", "5103.00", "5101.00",
3774                )
3775            } else {
3776                (
3777                    "5102.00", "5103.00", "5101.00", "5097.00", "5098.00", "5099.00",
3778                )
3779            };
3780
3781        for (id, source) in [
3782            ("O-UPDATE-QUOTE", quote_source),
3783            ("O-UPDATE-TRADE", TriggerType::LastPrice),
3784        ] {
3785            let order = OrderTestBuilder::new(order_type)
3786                .instrument_id(instrument.id())
3787                .client_order_id(ClientOrderId::from(id))
3788                .side(side)
3789                .price(Price::from("5100.00"))
3790                .trigger_price(Price::from("5100.00"))
3791                .quantity(Quantity::from(3))
3792                .emulation_trigger(source)
3793                .build();
3794            submit_to_emulator(&cache, &emulator, &instrument, &order);
3795        }
3796
3797        emulator.borrow_mut().on_quote_tick(create_quote_tick(
3798            &instrument,
3799            holding_bid,
3800            holding_ask,
3801        ));
3802        emulator
3803            .borrow_mut()
3804            .on_trade_tick(create_trade_tick(&instrument, holding_trade));
3805
3806        for step in 0..2 {
3807            let is_trade = (step == 0) == trade_first;
3808            if is_trade {
3809                emulator
3810                    .borrow_mut()
3811                    .on_trade_tick(create_trade_tick(&instrument, release_trade));
3812            } else {
3813                emulator.borrow_mut().on_quote_tick(create_quote_tick(
3814                    &instrument,
3815                    release_bid,
3816                    release_ask,
3817                ));
3818            }
3819
3820            let cache = cache.borrow();
3821            let emulator = emulator.borrow();
3822            let core = emulator.get_matching_core(&instrument.id()).unwrap();
3823
3824            for (id, is_trade_order) in [("O-UPDATE-QUOTE", false), ("O-UPDATE-TRADE", true)] {
3825                let id = ClientOrderId::from(id);
3826                let released = step == 1 || is_trade_order == is_trade;
3827                assert_eq!(
3828                    cache.order(&id).unwrap().status(),
3829                    if released {
3830                        OrderStatus::Released
3831                    } else {
3832                        OrderStatus::Emulated
3833                    }
3834                );
3835                assert_eq!(core.order_exists(id), !released);
3836                assert_eq!(
3837                    emulator.get_submit_order_commands().contains_key(&id),
3838                    !released
3839                );
3840            }
3841        }
3842
3843        let released: Vec<_> = events
3844            .get_messages()
3845            .into_iter()
3846            .filter_map(|event| match event {
3847                OrderEventAny::Released(event) => {
3848                    Some((event.client_order_id, event.released_price))
3849                }
3850                _ => None,
3851            })
3852            .collect();
3853
3854        let quote_price = Price::from(if side == OrderSide::Buy {
3855            release_ask
3856        } else {
3857            release_bid
3858        });
3859
3860        let mut expected = vec![
3861            (ClientOrderId::from("O-UPDATE-QUOTE"), quote_price),
3862            (
3863                ClientOrderId::from("O-UPDATE-TRADE"),
3864                Price::from(release_trade),
3865            ),
3866        ];
3867
3868        if trade_first {
3869            expected.reverse();
3870        }
3871
3872        assert_eq!(released, expected);
3873    }
3874
3875    #[rstest]
3876    #[case("5102.00", "5103.00", "5099.00", true)]
3877    #[case("5097.00", "5098.00", "5101.00", false)]
3878    fn test_modify_last_price_limit_uses_trade_in_mixed_core(
3879        instrument: CryptoPerpetual,
3880        #[case] bid: &str,
3881        #[case] ask: &str,
3882        #[case] trade: &str,
3883        #[case] released: bool,
3884    ) {
3885        let (_clock, cache, emulator) = create_emulator();
3886        let events = register_risk_event_handler("RiskEngine.process.modify_mixed_limit");
3887        add_instrument_to_cache(&cache, &instrument);
3888        cache
3889            .borrow_mut()
3890            .add_quote(create_quote_tick(&instrument, bid, ask))
3891            .unwrap();
3892        cache
3893            .borrow_mut()
3894            .add_trade(create_trade_tick(&instrument, trade))
3895            .unwrap();
3896        let quote_order = OrderTestBuilder::new(OrderType::StopMarket)
3897            .instrument_id(instrument.id())
3898            .client_order_id(ClientOrderId::from("O-MODIFY-QUOTE"))
3899            .side(OrderSide::Buy)
3900            .trigger_price(Price::from("6000.00"))
3901            .quantity(Quantity::from(2))
3902            .emulation_trigger(TriggerType::BidAsk)
3903            .build();
3904        let last_order = OrderTestBuilder::new(OrderType::Limit)
3905            .instrument_id(instrument.id())
3906            .client_order_id(ClientOrderId::from("O-MODIFY-LAST"))
3907            .side(OrderSide::Buy)
3908            .price(Price::from("5090.00"))
3909            .quantity(Quantity::from(3))
3910            .emulation_trigger(TriggerType::LastPrice)
3911            .build();
3912        submit_to_emulator(&cache, &emulator, &instrument, &quote_order);
3913        submit_to_emulator(&cache, &emulator, &instrument, &last_order);
3914
3915        let modify = ModifyOrder::new(
3916            last_order.trader_id(),
3917            None,
3918            last_order.strategy_id(),
3919            instrument.id(),
3920            last_order.client_order_id(),
3921            None,
3922            None,
3923            Some(Price::from("5100.00")),
3924            None,
3925            UUID4::new(),
3926            0.into(),
3927            None,
3928            None,
3929        );
3930
3931        emulator.borrow_mut().handle_modify_order(&modify);
3932
3933        let cache = cache.borrow();
3934        let emulator = emulator.borrow();
3935        let core = emulator.get_matching_core(&instrument.id()).unwrap();
3936        let cached = cache.order(&last_order.client_order_id()).unwrap();
3937        assert_eq!(
3938            cached.status(),
3939            if released {
3940                OrderStatus::Released
3941            } else {
3942                OrderStatus::Emulated
3943            }
3944        );
3945        assert_eq!(cached.quantity(), Quantity::from(3));
3946        assert_eq!(core.order_exists(last_order.client_order_id()), !released);
3947        assert_eq!(
3948            emulator
3949                .get_submit_order_commands()
3950                .contains_key(&last_order.client_order_id()),
3951            !released
3952        );
3953        assert_eq!(
3954            cache
3955                .order(&quote_order.client_order_id())
3956                .unwrap()
3957                .status(),
3958            OrderStatus::Emulated
3959        );
3960        assert!(core.order_exists(quote_order.client_order_id()));
3961        assert!(
3962            emulator
3963                .get_submit_order_commands()
3964                .contains_key(&quote_order.client_order_id())
3965        );
3966
3967        let release_prices: Vec<_> = events
3968            .get_messages()
3969            .into_iter()
3970            .filter_map(|event| match event {
3971                OrderEventAny::Released(event) => Some(event.released_price),
3972                _ => None,
3973            })
3974            .collect();
3975
3976        assert_eq!(
3977            release_prices,
3978            if released {
3979                vec![Price::from(trade)]
3980            } else {
3981                vec![]
3982            }
3983        );
3984    }
3985
3986    #[rstest]
3987    fn test_last_price_trailing_activation_uses_trade_in_mixed_core(
3988        instrument: CryptoPerpetual,
3989        #[values(TriggerType::Default, TriggerType::BidAsk, TriggerType::LastPrice)]
3990        trigger_type: TriggerType,
3991        #[values(OrderType::TrailingStopMarket, OrderType::TrailingStopLimit)]
3992        order_type: OrderType,
3993        #[values(false, true)] explicit_activation: bool,
3994    ) {
3995        let (_clock, cache, emulator) = create_emulator();
3996        let events = register_risk_event_handler("RiskEngine.process.mixed_trailing_activation");
3997        add_instrument_to_cache(&cache, &instrument);
3998        let quote_order = OrderTestBuilder::new(OrderType::StopMarket)
3999            .instrument_id(instrument.id())
4000            .client_order_id(ClientOrderId::from("O-ACTIVATION-QUOTE"))
4001            .side(OrderSide::Buy)
4002            .trigger_price(Price::from("7000.00"))
4003            .quantity(Quantity::from(2))
4004            .emulation_trigger(TriggerType::BidAsk)
4005            .build();
4006        let mut builder = OrderTestBuilder::new(order_type);
4007        builder
4008            .instrument_id(instrument.id())
4009            .client_order_id(ClientOrderId::from("O-ACTIVATION-LAST"))
4010            .side(OrderSide::Sell)
4011            .quantity(Quantity::from(3))
4012            .trigger_type(trigger_type)
4013            .trailing_offset(dec!(10))
4014            .limit_offset(dec!(12))
4015            .trailing_offset_type(TrailingOffsetType::Price)
4016            .emulation_trigger(TriggerType::LastPrice);
4017
4018        if explicit_activation {
4019            builder.activation_price(Price::from("5050.00"));
4020        }
4021
4022        let last_order = builder.build();
4023        submit_to_emulator(&cache, &emulator, &instrument, &quote_order);
4024        submit_to_emulator(&cache, &emulator, &instrument, &last_order);
4025        emulator
4026            .borrow_mut()
4027            .on_quote_tick(create_quote_tick(&instrument, "6000.00", "6001.00"));
4028        {
4029            let cache = cache.borrow();
4030            let cached = cache.order(&last_order.client_order_id()).unwrap();
4031            let emulator = emulator.borrow();
4032            let core = emulator.get_matching_core(&instrument.id()).unwrap();
4033            assert!(!is_order_activated(&cached));
4034            assert_eq!(cached.trigger_price(), None);
4035            assert_eq!(cached.status(), OrderStatus::Emulated);
4036            assert!(core.order_exists(last_order.client_order_id()));
4037            assert!(
4038                emulator
4039                    .get_submit_order_commands()
4040                    .contains_key(&last_order.client_order_id())
4041            );
4042        }
4043
4044        emulator
4045            .borrow_mut()
4046            .on_trade_tick(create_trade_tick(&instrument, "5000.00"));
4047        emulator
4048            .borrow_mut()
4049            .on_quote_tick(create_quote_tick(&instrument, "6000.00", "6001.00"));
4050        {
4051            let cache = cache.borrow();
4052            let cached = cache.order(&last_order.client_order_id()).unwrap();
4053
4054            assert_eq!(is_order_activated(&cached), !explicit_activation);
4055            assert_eq!(
4056                cached.trigger_price(),
4057                (!explicit_activation).then(|| Price::from("4990.00"))
4058            );
4059            assert_eq!(cached.status(), OrderStatus::Emulated);
4060        }
4061
4062        emulator
4063            .borrow_mut()
4064            .on_trade_tick(create_trade_tick(&instrument, "5055.00"));
4065        emulator
4066            .borrow_mut()
4067            .on_quote_tick(create_quote_tick(&instrument, "5100.00", "5101.00"));
4068        {
4069            let cache = cache.borrow();
4070            let cached = cache.order(&last_order.client_order_id()).unwrap();
4071
4072            assert!(is_order_activated(&cached));
4073            assert_eq!(cached.trigger_price(), Some(Price::from("5045.00")));
4074            assert_eq!(
4075                cached.price(),
4076                (order_type == OrderType::TrailingStopLimit).then(|| Price::from("5043.00"))
4077            );
4078            assert_eq!(cached.status(), OrderStatus::Emulated);
4079        }
4080
4081        emulator
4082            .borrow_mut()
4083            .on_trade_tick(create_trade_tick(&instrument, "5044.00"));
4084
4085        let cache = cache.borrow();
4086        let emulator = emulator.borrow();
4087        let core = emulator.get_matching_core(&instrument.id()).unwrap();
4088        let released = cache.order(&last_order.client_order_id()).unwrap();
4089        assert_eq!(released.status(), OrderStatus::Released);
4090        assert_eq!(released.quantity(), Quantity::from(3));
4091        assert_eq!(
4092            released.order_type(),
4093            if order_type == OrderType::TrailingStopLimit {
4094                OrderType::Limit
4095            } else {
4096                OrderType::Market
4097            }
4098        );
4099        assert_eq!(
4100            released.price(),
4101            (order_type == OrderType::TrailingStopLimit).then(|| Price::from("5043.00"))
4102        );
4103        assert!(!core.order_exists(last_order.client_order_id()));
4104        assert!(
4105            !emulator
4106                .get_submit_order_commands()
4107                .contains_key(&last_order.client_order_id())
4108        );
4109        assert!(core.order_exists(quote_order.client_order_id()));
4110
4111        let releases: Vec<_> = events
4112            .get_messages()
4113            .into_iter()
4114            .filter_map(|event| match event {
4115                OrderEventAny::Released(event) => {
4116                    Some((event.client_order_id, event.released_price))
4117                }
4118                _ => None,
4119            })
4120            .collect();
4121
4122        assert_eq!(
4123            releases,
4124            vec![(last_order.client_order_id(), Price::from("5044.00"))]
4125        );
4126    }
4127
4128    #[rstest]
4129    fn test_submit_order_preserves_existing_matching_core(
4130        instrument: CryptoPerpetual,
4131        #[values(TriggerType::BidAsk, TriggerType::LastPrice)] emulation_trigger: TriggerType,
4132    ) {
4133        let (_clock, cache, emulator) = create_emulator();
4134        let _risk_events = register_risk_event_handler("RiskEngine.process.cached_existing_core");
4135        add_instrument_to_cache(&cache, &instrument);
4136        cache
4137            .borrow_mut()
4138            .add_quote(create_quote_tick(&instrument, "5098.00", "5099.00"))
4139            .unwrap();
4140        cache
4141            .borrow_mut()
4142            .add_trade(create_trade_tick(&instrument, "5099.00"))
4143            .unwrap();
4144
4145        let first = create_stop_market_order(&instrument, emulation_trigger);
4146        let first_id = first.client_order_id();
4147        let first_command = create_submit_order(&instrument, &first);
4148        cache
4149            .borrow_mut()
4150            .add_order(first, None, None, false)
4151            .unwrap();
4152        emulator.borrow_mut().handle_submit_order(&first_command);
4153        cache
4154            .borrow_mut()
4155            .add_quote(create_quote_tick(&instrument, "5101.00", "5102.00"))
4156            .unwrap();
4157        cache
4158            .borrow_mut()
4159            .add_trade(create_trade_tick(&instrument, "5102.00"))
4160            .unwrap();
4161        let second = OrderTestBuilder::new(OrderType::StopMarket)
4162            .instrument_id(instrument.id())
4163            .client_order_id(ClientOrderId::from("O-CACHED-SECOND"))
4164            .side(OrderSide::Buy)
4165            .trigger_price(Price::from("5100.00"))
4166            .quantity(Quantity::from(1))
4167            .emulation_trigger(emulation_trigger)
4168            .build();
4169        let second_id = second.client_order_id();
4170        let second_command = create_submit_order(&instrument, &second);
4171        cache
4172            .borrow_mut()
4173            .add_order(second, None, None, false)
4174            .unwrap();
4175
4176        emulator.borrow_mut().handle_submit_order(&second_command);
4177
4178        let emulator = emulator.borrow();
4179        let core = emulator.get_matching_core(&instrument.id()).unwrap();
4180        assert_eq!(
4181            core.ask,
4182            (emulation_trigger != TriggerType::LastPrice).then(|| Price::from("5099.00"))
4183        );
4184        assert_eq!(
4185            core.last,
4186            (emulation_trigger == TriggerType::LastPrice).then(|| Price::from("5099.00"))
4187        );
4188        assert!(core.order_exists(first_id));
4189        assert!(core.order_exists(second_id));
4190        assert_eq!(
4191            cache.borrow().order(&first_id).unwrap().status(),
4192            OrderStatus::Emulated
4193        );
4194        assert_eq!(
4195            cache.borrow().order(&second_id).unwrap().status(),
4196            OrderStatus::Emulated
4197        );
4198    }
4199
4200    #[rstest]
4201    #[case(OrderType::StopMarket, ("5099.00", "5101.00"), "5099.00", "5101.00")]
4202    #[case(OrderType::Limit, ("5098.00", "5099.00"), "5101.00", "5099.00")]
4203    fn test_modify_last_price_order_ignores_cached_quote_before_first_trade(
4204        instrument: CryptoPerpetual,
4205        #[case] order_type: OrderType,
4206        #[case] quote: (&str, &str),
4207        #[case] trade: &str,
4208        #[case] next_trade: &str,
4209    ) {
4210        let (_clock, cache, emulator) = create_emulator();
4211        let risk_events = register_risk_event_handler("RiskEngine.process.modify_cached_quote");
4212        add_instrument_to_cache(&cache, &instrument);
4213        cache
4214            .borrow_mut()
4215            .add_quote(create_quote_tick(&instrument, quote.0, quote.1))
4216            .unwrap();
4217        cache
4218            .borrow_mut()
4219            .add_trade(create_trade_tick(&instrument, trade))
4220            .unwrap();
4221        let order = OrderTestBuilder::new(order_type)
4222            .instrument_id(instrument.id())
4223            .side(OrderSide::Buy)
4224            .trigger_price(Price::from("5150.00"))
4225            .price(Price::from("5050.00"))
4226            .quantity(Quantity::from(1))
4227            .emulation_trigger(TriggerType::LastPrice)
4228            .build();
4229        let client_order_id = order.client_order_id();
4230        let command = create_submit_order(&instrument, &order);
4231        cache
4232            .borrow_mut()
4233            .add_order(order.clone(), None, None, false)
4234            .unwrap();
4235        emulator.borrow_mut().handle_submit_order(&command);
4236
4237        let modify = ModifyOrder::new(
4238            order.trader_id(),
4239            None,
4240            order.strategy_id(),
4241            instrument.id(),
4242            client_order_id,
4243            None,
4244            None,
4245            (order_type == OrderType::Limit).then(|| Price::from("5100.00")),
4246            (order_type == OrderType::StopMarket).then(|| Price::from("5100.00")),
4247            UUID4::new(),
4248            0.into(),
4249            None,
4250            None,
4251        );
4252
4253        emulator.borrow_mut().handle_modify_order(&modify);
4254
4255        {
4256            let cache = cache.borrow();
4257            let cached_order = cache.order(&client_order_id).unwrap();
4258            let core = emulator
4259                .borrow()
4260                .get_matching_core(&instrument.id())
4261                .unwrap();
4262            assert_eq!(core.bid, None);
4263            assert_eq!(core.ask, None);
4264            assert_eq!(core.last, Some(Price::from(trade)));
4265            assert_eq!(cached_order.status(), OrderStatus::Emulated);
4266            assert_eq!(
4267                if order_type == OrderType::Limit {
4268                    cached_order.price()
4269                } else {
4270                    cached_order.trigger_price()
4271                },
4272                Some(Price::from("5100.00"))
4273            );
4274            assert!(matches!(risk_events.get_messages().as_slice(),
4275                [OrderEventAny::Emulated(event)] if event.client_order_id == client_order_id
4276            ));
4277        }
4278
4279        emulator
4280            .borrow_mut()
4281            .on_trade_tick(create_trade_tick(&instrument, next_trade));
4282
4283        assert_eq!(
4284            cache.borrow().order(&client_order_id).unwrap().status(),
4285            OrderStatus::Released
4286        );
4287        assert!(matches!(risk_events.get_messages().as_slice(),
4288            [OrderEventAny::Emulated(_), OrderEventAny::Released(event)]
4289                if event.client_order_id == client_order_id
4290                    && event.released_price == Price::from(next_trade)
4291        ));
4292    }
4293
4294    #[rstest]
4295    fn test_submit_limit_order_releases_when_immediately_fillable(instrument: CryptoPerpetual) {
4296        let (_clock, cache, emulator) = create_emulator();
4297        let risk_events =
4298            register_risk_event_handler("RiskEngine.process.submit_immediately_fillable");
4299        add_instrument_to_cache(&cache, &instrument);
4300        let mut core = OrderMatchingCore::new(instrument.id(), instrument.price_increment());
4301        core.set_bid_raw(Price::from("5099.00"));
4302        core.set_ask_raw(Price::from("5101.00"));
4303        emulator
4304            .borrow_mut()
4305            .matching_cores
4306            .insert(instrument.id(), core);
4307        let order = OrderTestBuilder::new(OrderType::Limit)
4308            .instrument_id(instrument.id())
4309            .side(OrderSide::Buy)
4310            .price(Price::from("5101.00"))
4311            .quantity(Quantity::from(1))
4312            .emulation_trigger(TriggerType::BidAsk)
4313            .build();
4314        let client_order_id = order.client_order_id();
4315        let command = create_submit_order(&instrument, &order);
4316        cache
4317            .borrow_mut()
4318            .add_order(order, None, None, false)
4319            .unwrap();
4320
4321        emulator.borrow_mut().handle_submit_order(&command);
4322
4323        let cache = cache.borrow();
4324        let cached_order = cache.order(&client_order_id).unwrap();
4325        let emulator = emulator.borrow();
4326        let matching_core = emulator.get_matching_core(&instrument.id()).unwrap();
4327        let risk_events = risk_events.get_messages();
4328        assert_eq!(cached_order.status(), OrderStatus::Released);
4329        assert_eq!(cached_order.order_type(), OrderType::Market);
4330        assert!(!matching_core.order_exists(client_order_id));
4331        assert!(
4332            !emulator
4333                .get_submit_order_commands()
4334                .contains_key(&client_order_id)
4335        );
4336        assert_eq!(risk_events.len(), 1);
4337        assert!(matches!(
4338            &risk_events[0],
4339            OrderEventAny::Released(event) if event.client_order_id == client_order_id
4340        ));
4341    }
4342
4343    #[rstest]
4344    fn test_modify_order_reindexes_matching_state(instrument: CryptoPerpetual) {
4345        let (_clock, cache, emulator) = create_emulator();
4346        add_instrument_to_cache(&cache, &instrument);
4347        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
4348        let client_order_id = order.client_order_id();
4349        let command = create_submit_order(&instrument, &order);
4350        cache
4351            .borrow_mut()
4352            .add_order(order.clone(), None, None, false)
4353            .unwrap();
4354        emulator.borrow_mut().handle_submit_order(&command);
4355        let exec_events =
4356            register_exec_event_handler(cache.clone(), "ExecEngine.process.modify_reindex");
4357        let portfolio_events = register_portfolio_event_handler("Portfolio.modify_reindex");
4358        let new_trigger = Price::from("5200.00");
4359        let modify = ModifyOrder::new(
4360            order.trader_id(),
4361            None,
4362            order.strategy_id(),
4363            instrument.id(),
4364            client_order_id,
4365            None,
4366            None,
4367            None,
4368            Some(new_trigger),
4369            UUID4::new(),
4370            0.into(),
4371            None,
4372            None,
4373        );
4374
4375        emulator.borrow_mut().handle_modify_order(&modify);
4376
4377        let cache = cache.borrow();
4378        let cached_order = cache.order(&client_order_id).unwrap();
4379        let emulator = emulator.borrow();
4380        let matching_core = emulator.get_matching_core(&instrument.id()).unwrap();
4381        let match_info = matching_core.get_order(client_order_id).unwrap();
4382        let portfolio_events = portfolio_events.get_messages();
4383        assert_eq!(cached_order.trigger_price(), Some(new_trigger));
4384        assert_eq!(match_info.trigger_price, Some(new_trigger));
4385        assert_eq!(matching_core.get_orders().len(), 1);
4386        assert!(exec_events.get_messages().is_empty());
4387        assert_eq!(portfolio_events.len(), 1);
4388        assert!(matches!(
4389            &portfolio_events[0],
4390            OrderEventAny::Updated(event) if event.client_order_id == client_order_id
4391        ));
4392    }
4393
4394    #[rstest]
4395    fn test_modify_order_releases_when_updated_trigger_matches(instrument: CryptoPerpetual) {
4396        let (_clock, cache, emulator) = create_emulator();
4397        let risk_events =
4398            register_risk_event_handler("RiskEngine.process.modify_immediately_triggered");
4399        add_instrument_to_cache(&cache, &instrument);
4400        let mut core = OrderMatchingCore::new(instrument.id(), instrument.price_increment());
4401        core.set_bid_raw(Price::from("5099.00"));
4402        core.set_ask_raw(Price::from("5101.00"));
4403        emulator
4404            .borrow_mut()
4405            .matching_cores
4406            .insert(instrument.id(), core);
4407        let order = OrderTestBuilder::new(OrderType::StopMarket)
4408            .instrument_id(instrument.id())
4409            .side(OrderSide::Buy)
4410            .trigger_price(Price::from("5200.00"))
4411            .quantity(Quantity::from(1))
4412            .emulation_trigger(TriggerType::BidAsk)
4413            .build();
4414        let client_order_id = order.client_order_id();
4415        let command = create_submit_order(&instrument, &order);
4416        cache
4417            .borrow_mut()
4418            .add_order(order.clone(), None, None, false)
4419            .unwrap();
4420        emulator.borrow_mut().handle_submit_order(&command);
4421        risk_events.clear();
4422        let exec_events = register_exec_event_handler(
4423            cache.clone(),
4424            "ExecEngine.process.modify_immediately_triggered",
4425        );
4426        let portfolio_events =
4427            register_portfolio_event_handler("Portfolio.modify_immediately_triggered");
4428
4429        let modify = ModifyOrder::new(
4430            order.trader_id(),
4431            None,
4432            order.strategy_id(),
4433            instrument.id(),
4434            client_order_id,
4435            None,
4436            None,
4437            None,
4438            Some(Price::from("5100.00")),
4439            UUID4::new(),
4440            0.into(),
4441            None,
4442            None,
4443        );
4444
4445        emulator.borrow_mut().handle_modify_order(&modify);
4446
4447        let cache = cache.borrow();
4448        let cached_order = cache.order(&client_order_id).unwrap();
4449        let emulator = emulator.borrow();
4450        let matching_core = emulator.get_matching_core(&instrument.id()).unwrap();
4451        let portfolio_events = portfolio_events.get_messages();
4452        let risk_events = risk_events.get_messages();
4453        assert_eq!(cached_order.status(), OrderStatus::Released);
4454        assert_eq!(cached_order.order_type(), OrderType::Market);
4455        assert!(!matching_core.order_exists(client_order_id));
4456        assert!(
4457            !emulator
4458                .get_submit_order_commands()
4459                .contains_key(&client_order_id)
4460        );
4461        assert!(exec_events.get_messages().is_empty());
4462        assert_eq!(portfolio_events.len(), 1);
4463        assert!(matches!(
4464            &portfolio_events[0],
4465            OrderEventAny::Updated(event) if event.client_order_id == client_order_id
4466        ));
4467        assert_eq!(risk_events.len(), 1);
4468        assert!(matches!(
4469            &risk_events[0],
4470            OrderEventAny::Released(event) if event.client_order_id == client_order_id
4471        ));
4472    }
4473
4474    #[rstest]
4475    fn test_update_order_applies_updated_event_to_cache(instrument: CryptoPerpetual) {
4476        let (_clock, cache, emulator) = create_emulator();
4477        let risk_events = register_risk_event_handler("RiskEngine.process.updated");
4478        let mut order = create_stop_market_order(&instrument, TriggerType::BidAsk);
4479        let client_order_id = order.client_order_id();
4480        cache
4481            .borrow_mut()
4482            .add_order(order.clone(), None, None, false)
4483            .unwrap();
4484
4485        emulator
4486            .borrow_mut()
4487            .update_order(&mut order, Quantity::from(2));
4488        let cache = cache.borrow();
4489        let cached_order = cache.order(&client_order_id).unwrap();
4490        let risk_events = risk_events.get_messages();
4491
4492        assert_eq!(order.quantity(), Quantity::from(2));
4493        assert_eq!(cached_order.quantity(), Quantity::from(2));
4494        assert_eq!(cached_order.status(), OrderStatus::Initialized);
4495        assert_eq!(risk_events.len(), 1);
4496        assert!(matches!(risk_events[0], OrderEventAny::Updated(_)));
4497    }
4498
4499    #[rstest]
4500    fn test_fill_market_order_applies_released_event_to_cache(instrument: CryptoPerpetual) {
4501        let (_clock, cache, emulator) = create_emulator();
4502        let risk_events = register_risk_event_handler("RiskEngine.process.released");
4503        add_instrument_to_cache(&cache, &instrument);
4504        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
4505        let client_order_id = order.client_order_id();
4506        let strategy_id = order.strategy_id();
4507        let command = create_submit_order(&instrument, &order);
4508        cache
4509            .borrow_mut()
4510            .add_order(order, None, None, false)
4511            .unwrap();
4512
4513        emulator
4514            .borrow_mut()
4515            .cache_submit_order_command(command.clone());
4516        emulator.borrow_mut().handle_submit_order(&command);
4517        risk_events.clear();
4518        let (order_handler, order_events) = subscribe_order_topic(strategy_id);
4519        {
4520            let mut emulator = emulator.borrow_mut();
4521            emulator
4522                .matching_cores
4523                .get_mut(&instrument.id())
4524                .unwrap()
4525                .set_ask_raw(Price::from("5100.00"));
4526            emulator.fill_market_order(client_order_id);
4527        }
4528
4529        msgbus::unsubscribe_order_events(
4530            format!("events.order.{strategy_id}").into(),
4531            &order_handler,
4532        );
4533        let cache = cache.borrow();
4534        let cached_order = cache.order(&client_order_id).unwrap();
4535        let risk_events = risk_events.get_messages();
4536        let order_events = order_events.borrow();
4537
4538        assert_eq!(cached_order.status(), OrderStatus::Released);
4539        assert_eq!(risk_events.len(), 1);
4540        assert!(matches!(risk_events[0], OrderEventAny::Released(_)));
4541        assert_eq!(order_events.len(), 2);
4542        assert!(matches!(order_events[0], OrderEventAny::Initialized(_)));
4543        assert!(matches!(order_events[1], OrderEventAny::Released(_)));
4544    }
4545
4546    #[rstest]
4547    fn test_fill_limit_order_publishes_transformed_initialized_before_released(
4548        instrument: CryptoPerpetual,
4549    ) {
4550        let (_clock, cache, emulator) = create_emulator();
4551        let risk_events = register_risk_event_handler("RiskEngine.process.limit_released");
4552        add_instrument_to_cache(&cache, &instrument);
4553        let order = create_stop_limit_order(&instrument, TriggerType::BidAsk);
4554        let client_order_id = order.client_order_id();
4555        let strategy_id = order.strategy_id();
4556        let command = create_submit_order(&instrument, &order);
4557        cache
4558            .borrow_mut()
4559            .add_order(order, None, None, false)
4560            .unwrap();
4561
4562        emulator
4563            .borrow_mut()
4564            .cache_submit_order_command(command.clone());
4565        emulator.borrow_mut().handle_submit_order(&command);
4566        risk_events.clear();
4567        let (order_handler, order_events) = subscribe_order_topic(strategy_id);
4568        {
4569            let mut emulator = emulator.borrow_mut();
4570            emulator
4571                .matching_cores
4572                .get_mut(&instrument.id())
4573                .unwrap()
4574                .set_ask_raw(Price::from("5100.00"));
4575            emulator.fill_limit_order(client_order_id);
4576        }
4577
4578        msgbus::unsubscribe_order_events(
4579            format!("events.order.{strategy_id}").into(),
4580            &order_handler,
4581        );
4582        let cache = cache.borrow();
4583        let cached_order = cache.order(&client_order_id).unwrap();
4584        let risk_events = risk_events.get_messages();
4585        let order_events = order_events.borrow();
4586
4587        assert_eq!(cached_order.status(), OrderStatus::Released);
4588        assert_eq!(risk_events.len(), 1);
4589        assert!(matches!(risk_events[0], OrderEventAny::Released(_)));
4590        assert_eq!(order_events.len(), 2);
4591        assert!(matches!(order_events[0], OrderEventAny::Initialized(_)));
4592        assert!(matches!(order_events[1], OrderEventAny::Released(_)));
4593    }
4594
4595    fn register_risk_command_handler(id: &str) -> TypedIntoMessageSavingHandler<TradingCommand> {
4596        let (handler, saving_handler) =
4597            get_typed_into_message_saving_handler::<TradingCommand>(Some(Ustr::from(id)));
4598        msgbus::register_trading_command_endpoint(
4599            MessagingSwitchboard::risk_engine_queue_execute(),
4600            handler,
4601        );
4602        saving_handler
4603    }
4604
4605    fn submit_to_emulator(
4606        cache: &Rc<RefCell<Cache>>,
4607        emulator: &Rc<RefCell<OrderEmulator>>,
4608        instrument: &CryptoPerpetual,
4609        order: &OrderAny,
4610    ) {
4611        let command = create_submit_order(instrument, order);
4612        cache
4613            .borrow_mut()
4614            .add_order(order.clone(), None, None, false)
4615            .unwrap();
4616        emulator
4617            .borrow_mut()
4618            .cache_submit_order_command(command.clone());
4619        emulator.borrow_mut().handle_submit_order(&command);
4620    }
4621
4622    #[rstest]
4623    fn test_release_without_market_data_retains_command_and_retries(
4624        instrument: CryptoPerpetual,
4625        #[values(OrderType::StopLimit, OrderType::StopMarket, OrderType::Limit)]
4626        order_type: OrderType,
4627        #[values(OrderSide::Buy, OrderSide::Sell)] side: OrderSide,
4628        #[values(false, true)] use_algorithm: bool,
4629    ) {
4630        let (_clock, cache, emulator) = create_emulator();
4631        let risk_events = register_risk_event_handler("RiskEngine.process.release_retry");
4632        let risk_commands = register_risk_command_handler("RiskEngine.queue_execute.release_retry");
4633        let endpoint = Ustr::from("ALG-RETRY.execute");
4634        let (handler, algo_commands) = get_any_saving_handler::<TradingCommand>(Some(endpoint));
4635        msgbus::register_any(endpoint.into(), handler);
4636        add_instrument_to_cache(&cache, &instrument);
4637        let mut builder = OrderTestBuilder::new(order_type);
4638        builder
4639            .instrument_id(instrument.id())
4640            .side(side)
4641            .price(match side {
4642                OrderSide::Buy => Price::from("5102.00"),
4643                OrderSide::Sell => Price::from("5098.00"),
4644            })
4645            .trigger_price(Price::from("5100.00"))
4646            .quantity(Quantity::from(3))
4647            .emulation_trigger(TriggerType::BidAsk);
4648
4649        if use_algorithm {
4650            builder
4651                .exec_algorithm_id(ExecAlgorithmId::from("ALG-RETRY"))
4652                .exec_spawn_id(ClientOrderId::from("O-SPAWN-RETRY"));
4653        }
4654
4655        let order = builder.build();
4656        let client_order_id = order.client_order_id();
4657        let command = create_submit_order(&instrument, &order);
4658        cache
4659            .borrow_mut()
4660            .add_order(order.clone(), None, None, false)
4661            .unwrap();
4662        emulator.borrow_mut().handle_submit_order(&command);
4663        let held_order = cache.borrow().order(&client_order_id).unwrap().clone();
4664        let held_entry = *emulator
4665            .borrow()
4666            .get_matching_core(&instrument.id())
4667            .unwrap()
4668            .get_order(client_order_id)
4669            .unwrap();
4670        risk_events.clear();
4671        let (order_handler, order_events) = subscribe_order_topic(order.strategy_id());
4672
4673        {
4674            let mut emulator = emulator.borrow_mut();
4675            let core = emulator.matching_cores.get_mut(&instrument.id()).unwrap();
4676
4677            // The opposite quote side cannot supply the release price
4678            match side {
4679                OrderSide::Buy => core.set_bid_raw(Price::from("5099.00")),
4680                OrderSide::Sell => core.set_ask_raw(Price::from("5101.00")),
4681            }
4682
4683            match order_type {
4684                OrderType::StopMarket => emulator.fill_market_order(client_order_id),
4685                _ => emulator.fill_limit_order(client_order_id),
4686            }
4687        }
4688
4689        {
4690            let emulator = emulator.borrow();
4691            let cache = cache.borrow();
4692            let cached_order = cache.order(&client_order_id).unwrap();
4693            assert_eq!(cached_order.status(), OrderStatus::Emulated);
4694            assert_eq!(cached_order.order_type(), order_type);
4695            assert_eq!(cached_order.events(), held_order.events());
4696            assert_eq!(
4697                emulator.get_submit_order_commands().get(&client_order_id),
4698                Some(&command),
4699            );
4700            assert_eq!(
4701                emulator
4702                    .get_matching_core(&instrument.id())
4703                    .unwrap()
4704                    .get_order(client_order_id),
4705                Some(&held_entry),
4706            );
4707            assert!(risk_events.get_messages().is_empty());
4708            assert!(order_events.borrow().is_empty());
4709            assert!(risk_commands.get_messages().is_empty());
4710            assert!(algo_commands.get_messages().is_empty());
4711        }
4712
4713        let quote = create_quote_tick(&instrument, "5099.00", "5101.00");
4714        emulator.borrow_mut().on_quote_tick(quote);
4715        emulator.borrow_mut().on_quote_tick(quote);
4716        msgbus::unsubscribe_order_events(
4717            format!("events.order.{}", order.strategy_id()).into(),
4718            &order_handler,
4719        );
4720        let risk_commands = risk_commands.get_messages();
4721        let algo_commands = algo_commands.get_messages();
4722        let (commands, other_commands) = if use_algorithm {
4723            (&algo_commands, &risk_commands)
4724        } else {
4725            (&risk_commands, &algo_commands)
4726        };
4727
4728        let [TradingCommand::SubmitOrder(released_command)] = commands.as_slice() else {
4729            panic!("Expected one released SubmitOrder, was {commands:?}");
4730        };
4731
4732        let emulator = emulator.borrow();
4733        let cache = cache.borrow();
4734        let cached_order = cache.order(&client_order_id).unwrap();
4735        let events = cached_order.events();
4736        let order_events = order_events.borrow();
4737        let mut expected_command = command;
4738        expected_command.order_init = OrderInitialized::from(&*cached_order);
4739
4740        let released_price = match side {
4741            OrderSide::Buy => Price::from("5101.00"),
4742            OrderSide::Sell => Price::from("5099.00"),
4743        };
4744
4745        assert_eq!(cached_order.status(), OrderStatus::Released);
4746        assert_eq!(
4747            cached_order.order_type(),
4748            match order_type {
4749                OrderType::StopLimit => OrderType::Limit,
4750                _ => OrderType::Market,
4751            },
4752        );
4753        assert_eq!(cached_order.emulation_trigger(), None);
4754        assert_eq!(&events[..held_order.event_count()], held_order.events());
4755        assert_eq!(events.len(), held_order.event_count() + 2);
4756        assert_eq!(
4757            order_events.as_slice(),
4758            [
4759                OrderEventAny::Initialized(released_command.order_init.clone()),
4760                cached_order.last_event().clone(),
4761            ],
4762        );
4763        assert!(matches!(
4764            cached_order.last_event(),
4765            OrderEventAny::Released(event) if event.released_price == released_price
4766        ));
4767        assert_eq!(
4768            risk_events.get_messages(),
4769            [cached_order.last_event().clone()]
4770        );
4771        assert_eq!(released_command, &expected_command);
4772        assert!(other_commands.is_empty());
4773        assert!(emulator.get_submit_order_commands().is_empty());
4774        assert_eq!(
4775            emulator
4776                .get_matching_core(&instrument.id())
4777                .unwrap()
4778                .get_order(client_order_id),
4779            None,
4780        );
4781    }
4782
4783    #[rstest]
4784    fn test_release_updates_cache_before_publication_and_defers_reentrant_commands(
4785        instrument: CryptoPerpetual,
4786        #[values(OrderType::StopLimit, OrderType::StopMarket)] order_type: OrderType,
4787    ) {
4788        let (_clock, cache, emulator) = create_emulator();
4789        let risk_commands =
4790            register_risk_command_handler("RiskEngine.queue_execute.release_events");
4791        add_instrument_to_cache(&cache, &instrument);
4792        let order = OrderTestBuilder::new(order_type)
4793            .instrument_id(instrument.id())
4794            .side(OrderSide::Buy)
4795            .price(Price::from("5102.00"))
4796            .trigger_price(Price::from("5100.00"))
4797            .quantity(Quantity::from(3))
4798            .emulation_trigger(TriggerType::BidAsk)
4799            .build();
4800        let sibling = OrderTestBuilder::new(OrderType::StopMarket)
4801            .instrument_id(instrument.id())
4802            .client_order_id(ClientOrderId::from("O-REENTRANT-CANCEL"))
4803            .side(OrderSide::Buy)
4804            .trigger_price(Price::from("5200.00"))
4805            .quantity(Quantity::from(2))
4806            .emulation_trigger(TriggerType::BidAsk)
4807            .build();
4808        submit_to_emulator(&cache, &emulator, &instrument, &order);
4809        submit_to_emulator(&cache, &emulator, &instrument, &sibling);
4810        let client_order_id = order.client_order_id();
4811
4812        let cancel = CancelOrder::new(
4813            sibling.trader_id(),
4814            None,
4815            sibling.strategy_id(),
4816            sibling.instrument_id(),
4817            sibling.client_order_id(),
4818            None,
4819            UUID4::new(),
4820            0.into(),
4821            None,
4822            None,
4823        );
4824        let observed = Rc::new(RefCell::new(Vec::new()));
4825
4826        msgbus::register_trading_command_endpoint(
4827            MessagingSwitchboard::risk_engine_queue_execute(),
4828            TypedIntoHandler::from({
4829                let cache = cache.clone();
4830                let observed = observed.clone();
4831                let exec_handler = risk_commands.handler();
4832                move |command: TradingCommand| {
4833                    let cached_order = cache.borrow().order_owned(&client_order_id).unwrap();
4834                    observed.borrow_mut().push((
4835                        "exec",
4836                        cached_order.status(),
4837                        cached_order.order_type(),
4838                        cached_order.last_event().clone(),
4839                    ));
4840                    exec_handler.handle(command);
4841                }
4842            }),
4843        );
4844
4845        let order_handler = TypedHandler::from({
4846            let cache = cache.clone();
4847            let observed = observed.clone();
4848            move |event: &OrderEventAny| {
4849                if event.client_order_id() != client_order_id {
4850                    return;
4851                }
4852
4853                let cached_order = cache.borrow().order_owned(&client_order_id).unwrap();
4854                observed.borrow_mut().push((
4855                    "order",
4856                    cached_order.status(),
4857                    cached_order.order_type(),
4858                    cached_order.last_event().clone(),
4859                ));
4860
4861                if matches!(event, OrderEventAny::Initialized(_)) {
4862                    assert!(!cache.borrow().is_order_emulated(&client_order_id));
4863                    msgbus::send_trading_command(
4864                        MessagingSwitchboard::order_emulator_execute(),
4865                        TradingCommand::CancelOrder(cancel.clone()),
4866                    );
4867                }
4868            }
4869        });
4870
4871        msgbus::subscribe_order_events(
4872            format!("events.order.{}", order.strategy_id()).into(),
4873            order_handler.clone(),
4874            None,
4875        );
4876        msgbus::register_order_event_endpoint(
4877            MessagingSwitchboard::risk_engine_process(),
4878            TypedIntoHandler::from({
4879                let cache = cache.clone();
4880                let observed = observed.clone();
4881                move |event: OrderEventAny| {
4882                    if event.client_order_id() != client_order_id {
4883                        return;
4884                    }
4885
4886                    let cached_order = cache.borrow().order_owned(&client_order_id).unwrap();
4887                    observed.borrow_mut().push((
4888                        "risk",
4889                        cached_order.status(),
4890                        cached_order.order_type(),
4891                        cached_order.last_event().clone(),
4892                    ));
4893                }
4894            }),
4895        );
4896
4897        emulator
4898            .borrow_mut()
4899            .on_quote_tick(create_quote_tick(&instrument, "5099.00", "5101.00"));
4900        msgbus::unsubscribe_order_events(
4901            format!("events.order.{}", order.strategy_id()).into(),
4902            &order_handler,
4903        );
4904        let cache = cache.borrow();
4905        let cached_order = cache.order(&client_order_id).unwrap();
4906        let events = cached_order.events();
4907
4908        let released_type = match order_type {
4909            OrderType::StopLimit => OrderType::Limit,
4910            _ => OrderType::Market,
4911        };
4912
4913        assert_eq!(
4914            observed.borrow().as_slice(),
4915            [
4916                (
4917                    "order",
4918                    OrderStatus::Initialized,
4919                    released_type,
4920                    events[events.len() - 2].clone(),
4921                ),
4922                (
4923                    "risk",
4924                    OrderStatus::Released,
4925                    released_type,
4926                    cached_order.last_event().clone(),
4927                ),
4928                (
4929                    "order",
4930                    OrderStatus::Released,
4931                    released_type,
4932                    cached_order.last_event().clone(),
4933                ),
4934                (
4935                    "exec",
4936                    OrderStatus::Released,
4937                    released_type,
4938                    cached_order.last_event().clone(),
4939                ),
4940            ],
4941        );
4942        assert_eq!(
4943            cache.order(&sibling.client_order_id()).unwrap().status(),
4944            OrderStatus::Canceled,
4945        );
4946        assert!(matches!(
4947            risk_commands.get_messages().as_slice(),
4948            [TradingCommand::SubmitOrder(command)] if command.client_order_id == client_order_id
4949        ));
4950        assert!(emulator.borrow().get_submit_order_commands().is_empty());
4951        assert!(
4952            emulator
4953                .borrow()
4954                .get_matching_core(&instrument.id())
4955                .unwrap()
4956                .get_orders()
4957                .is_empty()
4958        );
4959    }
4960
4961    #[rstest]
4962    fn test_release_stops_when_cached_order_rejects_released_event(
4963        instrument: CryptoPerpetual,
4964        #[values(OrderType::StopLimit, OrderType::StopMarket)] order_type: OrderType,
4965    ) {
4966        let (_clock, cache, emulator) = create_emulator();
4967        let risk_events = register_risk_event_handler("RiskEngine.process.release_rejected");
4968        let risk_commands =
4969            register_risk_command_handler("RiskEngine.queue_execute.release_rejected");
4970        add_instrument_to_cache(&cache, &instrument);
4971        let order = OrderTestBuilder::new(order_type)
4972            .instrument_id(instrument.id())
4973            .side(OrderSide::Buy)
4974            .price(Price::from("5102.00"))
4975            .trigger_price(Price::from("5100.00"))
4976            .quantity(Quantity::from(3))
4977            .emulation_trigger(TriggerType::BidAsk)
4978            .build();
4979        submit_to_emulator(&cache, &emulator, &instrument, &order);
4980        let client_order_id = order.client_order_id();
4981        let held_order = cache.borrow().order_owned(&client_order_id).unwrap();
4982        let canceled =
4983            TestOrderEventStubs::canceled(&order, AccountId::from("ACCOUNT-RELEASE"), None);
4984        let observed = Rc::new(RefCell::new(Vec::new()));
4985
4986        let order_handler = TypedHandler::from({
4987            let cache = cache.clone();
4988            let canceled = canceled.clone();
4989            let observed = observed.clone();
4990            move |event: &OrderEventAny| {
4991                observed.borrow_mut().push(event.clone());
4992
4993                if matches!(event, OrderEventAny::Initialized(_)) {
4994                    cache.borrow_mut().update_order(&canceled).unwrap();
4995                }
4996            }
4997        });
4998
4999        msgbus::subscribe_order_events(
5000            format!("events.order.{}", order.strategy_id()).into(),
5001            order_handler.clone(),
5002            None,
5003        );
5004        risk_events.clear();
5005
5006        emulator
5007            .borrow_mut()
5008            .on_quote_tick(create_quote_tick(&instrument, "5099.00", "5101.00"));
5009        msgbus::unsubscribe_order_events(
5010            format!("events.order.{}", order.strategy_id()).into(),
5011            &order_handler,
5012        );
5013
5014        let cache = cache.borrow();
5015        let cached_order = cache.order(&client_order_id).unwrap();
5016        let events = cached_order.events();
5017        let mut expected_events = held_order.events();
5018        expected_events.push(events[held_order.events().len()]);
5019        expected_events.push(&canceled);
5020
5021        assert_eq!(cached_order.status(), OrderStatus::Canceled);
5022        assert_eq!(events, expected_events);
5023        assert!(matches!(
5024            events[events.len() - 2],
5025            OrderEventAny::Initialized(_)
5026        ));
5027        assert_eq!(
5028            observed.borrow().as_slice(),
5029            [events[events.len() - 2].clone()]
5030        );
5031        assert!(risk_events.get_messages().is_empty());
5032        assert!(risk_commands.get_messages().is_empty());
5033        assert!(emulator.borrow().get_submit_order_commands().is_empty());
5034        assert!(
5035            emulator
5036                .borrow()
5037                .get_matching_core(&instrument.id())
5038                .unwrap()
5039                .get_orders()
5040                .is_empty()
5041        );
5042    }
5043
5044    #[rstest]
5045    fn test_fill_limit_order_without_command_retains_order(instrument: CryptoPerpetual) {
5046        let (_clock, cache, emulator) = create_emulator();
5047        let risk_commands = register_risk_command_handler("RiskEngine.queue_execute.no_command");
5048        add_instrument_to_cache(&cache, &instrument);
5049        let order = create_stop_limit_order(&instrument, TriggerType::BidAsk);
5050        let client_order_id = order.client_order_id();
5051        submit_to_emulator(&cache, &emulator, &instrument, &order);
5052        let held_order = cache.borrow().order(&client_order_id).unwrap().clone();
5053        let mut emulator = emulator.borrow_mut();
5054        let command = emulator
5055            .manager
5056            .pop_submit_order_command(client_order_id)
5057            .unwrap();
5058        emulator
5059            .matching_cores
5060            .get_mut(&instrument.id())
5061            .unwrap()
5062            .set_ask_raw(Price::from("5101.00"));
5063
5064        emulator.fill_limit_order(client_order_id);
5065
5066        let cache = cache.borrow();
5067        let cached_order = cache.order(&client_order_id).unwrap();
5068        assert_eq!(command.client_order_id, client_order_id);
5069        assert_eq!(cached_order.status(), OrderStatus::Emulated);
5070        assert_eq!(cached_order.order_type(), OrderType::StopLimit);
5071        assert_eq!(cached_order.events(), held_order.events());
5072        assert!(
5073            emulator
5074                .get_matching_core(&instrument.id())
5075                .unwrap()
5076                .order_exists(client_order_id)
5077        );
5078        assert!(risk_commands.get_messages().is_empty());
5079    }
5080
5081    #[rstest]
5082    #[should_panic(expected = "invalid operation `fill_market_order` with no command")]
5083    fn test_fill_market_order_without_command_panics(
5084        instrument: CryptoPerpetual,
5085        #[values(OrderType::StopMarket, OrderType::Limit)] order_type: OrderType,
5086    ) {
5087        let (_clock, cache, emulator) = create_emulator();
5088        add_instrument_to_cache(&cache, &instrument);
5089        let order = OrderTestBuilder::new(order_type)
5090            .instrument_id(instrument.id())
5091            .side(OrderSide::Buy)
5092            .price(Price::from("5102.00"))
5093            .trigger_price(Price::from("5100.00"))
5094            .quantity(Quantity::from(3))
5095            .emulation_trigger(TriggerType::BidAsk)
5096            .build();
5097        let client_order_id = order.client_order_id();
5098        submit_to_emulator(&cache, &emulator, &instrument, &order);
5099        let mut emulator = emulator.borrow_mut();
5100        emulator
5101            .manager
5102            .pop_submit_order_command(client_order_id)
5103            .unwrap();
5104        emulator
5105            .matching_cores
5106            .get_mut(&instrument.id())
5107            .unwrap()
5108            .set_ask_raw(Price::from("5101.00"));
5109
5110        match order_type {
5111            OrderType::Limit => emulator.fill_limit_order(client_order_id),
5112            _ => emulator.fill_market_order(client_order_id),
5113        }
5114    }
5115
5116    #[rstest]
5117    fn test_release_gtd_stop_market_as_gtc_market_order(instrument: CryptoPerpetual) {
5118        let (_clock, cache, emulator) = create_emulator();
5119        let risk_commands = register_risk_command_handler("RiskEngine.queue_execute.gtd");
5120        add_instrument_to_cache(&cache, &instrument);
5121        let order = OrderTestBuilder::new(OrderType::StopMarket)
5122            .instrument_id(instrument.id())
5123            .side(OrderSide::Buy)
5124            .trigger_price(Price::from("5100.00"))
5125            .quantity(Quantity::from(1))
5126            .time_in_force(TimeInForce::Gtd)
5127            .expire_time(UnixNanos::from(1_000_000_000_000))
5128            .emulation_trigger(TriggerType::BidAsk)
5129            .build();
5130        let client_order_id = order.client_order_id();
5131        submit_to_emulator(&cache, &emulator, &instrument, &order);
5132
5133        emulator
5134            .borrow_mut()
5135            .on_quote_tick(create_quote_tick(&instrument, "5100.00", "5101.00"));
5136
5137        let cache = cache.borrow();
5138        let cached_order = cache.order(&client_order_id).unwrap();
5139        assert_eq!(cached_order.order_type(), OrderType::Market);
5140        assert_eq!(cached_order.time_in_force(), TimeInForce::Gtc);
5141        assert_eq!(cached_order.status(), OrderStatus::Released);
5142        assert!(matches!(
5143            risk_commands.get_messages().as_slice(),
5144            [TradingCommand::SubmitOrder(command)] if command.client_order_id == client_order_id
5145        ));
5146    }
5147
5148    #[rstest]
5149    fn test_last_price_emulated_stop_triggers_on_trades_not_quotes(
5150        instrument: CryptoPerpetual,
5151        #[values(false, true)] modified: bool,
5152    ) {
5153        let (_clock, cache, emulator) = create_emulator();
5154        let _data_commands = register_data_command_handler("DataEngine.queue_execute.last_price");
5155        let risk_commands = register_risk_command_handler("RiskEngine.queue_execute.last_price");
5156        add_instrument_to_cache(&cache, &instrument);
5157
5158        // A quote-triggered order on the same instrument subscribes the emulator to quotes
5159        let quote_order = OrderTestBuilder::new(OrderType::StopMarket)
5160            .instrument_id(instrument.id())
5161            .client_order_id(ClientOrderId::from("O-QUOTE"))
5162            .side(OrderSide::Buy)
5163            .trigger_price(Price::from("5200.00"))
5164            .quantity(Quantity::from(1))
5165            .emulation_trigger(TriggerType::BidAsk)
5166            .build();
5167
5168        // The modified case re-indexes the order through the modify path
5169        let initial_trigger = if modified { "5150.00" } else { "5100.00" };
5170        let last_order = OrderTestBuilder::new(OrderType::StopMarket)
5171            .instrument_id(instrument.id())
5172            .client_order_id(ClientOrderId::from("O-LAST"))
5173            .side(OrderSide::Buy)
5174            .trigger_price(Price::from(initial_trigger))
5175            .quantity(Quantity::from(1))
5176            .emulation_trigger(TriggerType::LastPrice)
5177            .build();
5178        submit_to_emulator(&cache, &emulator, &instrument, &quote_order);
5179        submit_to_emulator(&cache, &emulator, &instrument, &last_order);
5180
5181        if modified {
5182            let modify = ModifyOrder::new(
5183                last_order.trader_id(),
5184                None,
5185                last_order.strategy_id(),
5186                instrument.id(),
5187                last_order.client_order_id(),
5188                None,
5189                None,
5190                None,
5191                Some(Price::from("5100.00")),
5192                UUID4::new(),
5193                0.into(),
5194                None,
5195                None,
5196            );
5197            emulator.borrow_mut().handle_modify_order(&modify);
5198        }
5199
5200        emulator
5201            .borrow_mut()
5202            .on_quote_tick(create_quote_tick(&instrument, "5100.00", "5101.00"));
5203        let commands_after_quote = risk_commands.get_messages().len();
5204        emulator
5205            .borrow_mut()
5206            .on_trade_tick(create_trade_tick(&instrument, "5101.00"));
5207
5208        assert_eq!(commands_after_quote, 0);
5209        assert!(matches!(
5210            risk_commands.get_messages().as_slice(),
5211            [TradingCommand::SubmitOrder(command)]
5212                if command.client_order_id == last_order.client_order_id()
5213        ));
5214    }
5215
5216    #[rstest]
5217    fn test_last_price_emulated_trailing_stop_triggers_on_trades_not_quotes(
5218        instrument: CryptoPerpetual,
5219    ) {
5220        let (_clock, cache, emulator) = create_emulator();
5221        let _data_commands = register_data_command_handler("DataEngine.queue_execute.trailing");
5222        let risk_commands = register_risk_command_handler("RiskEngine.queue_execute.trailing");
5223        add_instrument_to_cache(&cache, &instrument);
5224        let quote_order = OrderTestBuilder::new(OrderType::StopMarket)
5225            .instrument_id(instrument.id())
5226            .client_order_id(ClientOrderId::from("O-QUOTE"))
5227            .side(OrderSide::Buy)
5228            .trigger_price(Price::from("5200.00"))
5229            .quantity(Quantity::from(1))
5230            .emulation_trigger(TriggerType::BidAsk)
5231            .build();
5232        let trailing_order = OrderTestBuilder::new(OrderType::TrailingStopMarket)
5233            .instrument_id(instrument.id())
5234            .client_order_id(ClientOrderId::from("O-TRAILING"))
5235            .side(OrderSide::Sell)
5236            .quantity(Quantity::from(1))
5237            .trigger_type(TriggerType::LastPrice)
5238            .trailing_offset(dec!(10))
5239            .trailing_offset_type(TrailingOffsetType::Price)
5240            .emulation_trigger(TriggerType::LastPrice)
5241            .build();
5242        submit_to_emulator(&cache, &emulator, &instrument, &quote_order);
5243        submit_to_emulator(&cache, &emulator, &instrument, &trailing_order);
5244
5245        // The first trade activates the stop and trails its trigger to 4990
5246        emulator
5247            .borrow_mut()
5248            .on_trade_tick(create_trade_tick(&instrument, "5000.00"));
5249        let trigger_price = cache
5250            .borrow()
5251            .order(&trailing_order.client_order_id())
5252            .unwrap()
5253            .trigger_price();
5254        emulator
5255            .borrow_mut()
5256            .on_quote_tick(create_quote_tick(&instrument, "4980.00", "4981.00"));
5257        let commands_after_quote = risk_commands.get_messages().len();
5258        emulator
5259            .borrow_mut()
5260            .on_trade_tick(create_trade_tick(&instrument, "4985.00"));
5261
5262        assert_eq!(trigger_price, Some(Price::from("4990.00")));
5263        assert_eq!(commands_after_quote, 0);
5264        assert!(matches!(
5265            risk_commands.get_messages().as_slice(),
5266            [TradingCommand::SubmitOrder(command)]
5267                if command.client_order_id == trailing_order.client_order_id()
5268        ));
5269    }
5270
5271    #[rstest]
5272    fn test_failed_limit_release_keeps_order_emulated(instrument: CryptoPerpetual) {
5273        let (_clock, cache, emulator) = create_emulator();
5274        let risk_commands = register_risk_command_handler("RiskEngine.queue_execute.failed");
5275        add_instrument_to_cache(&cache, &instrument);
5276        let mut order = OrderTestBuilder::new(OrderType::StopLimit)
5277            .instrument_id(instrument.id())
5278            .side(OrderSide::Buy)
5279            .price(Price::from("5100.00"))
5280            .trigger_price(Price::from("5100.00"))
5281            .quantity(Quantity::from(10))
5282            .display_qty(Quantity::from(5))
5283            .emulation_trigger(TriggerType::BidAsk)
5284            .build();
5285        let client_order_id = order.client_order_id();
5286        submit_to_emulator(&cache, &emulator, &instrument, &order);
5287
5288        // A display quantity above the reduced quantity cannot form a limit order on release
5289        emulator
5290            .borrow_mut()
5291            .update_order(&mut order, Quantity::from(3));
5292
5293        emulator
5294            .borrow_mut()
5295            .on_quote_tick(create_quote_tick(&instrument, "5100.00", "5101.00"));
5296
5297        let emulator = emulator.borrow();
5298        let cache = cache.borrow();
5299        assert_eq!(
5300            cache.order(&client_order_id).unwrap().status(),
5301            OrderStatus::Emulated
5302        );
5303        assert!(
5304            emulator
5305                .get_submit_order_commands()
5306                .contains_key(&client_order_id)
5307        );
5308        assert!(
5309            emulator
5310                .get_matching_core(&instrument.id())
5311                .unwrap()
5312                .order_exists(client_order_id)
5313        );
5314        assert!(risk_commands.get_messages().is_empty());
5315    }
5316
5317    #[rstest]
5318    #[case(
5319        OrderType::StopMarket,
5320        OrderType::Market,
5321        TimeInForce::Gtc,
5322        TimeInForce::Gtc
5323    )]
5324    #[case(
5325        OrderType::StopMarket,
5326        OrderType::Market,
5327        TimeInForce::Gtd,
5328        TimeInForce::Gtc
5329    )]
5330    #[case(
5331        OrderType::StopLimit,
5332        OrderType::Limit,
5333        TimeInForce::Gtc,
5334        TimeInForce::Gtc
5335    )]
5336    #[case(
5337        OrderType::StopLimit,
5338        OrderType::Limit,
5339        TimeInForce::Gtd,
5340        TimeInForce::Gtd
5341    )]
5342    fn test_release_order_sends_transformed_command(
5343        instrument: CryptoPerpetual,
5344        #[case] order_type: OrderType,
5345        #[case] released_type: OrderType,
5346        #[case] time_in_force: TimeInForce,
5347        #[case] released_time_in_force: TimeInForce,
5348        #[values(false, true)] use_algorithm: bool,
5349    ) {
5350        let (clock, cache, emulator) = create_emulator();
5351        let release_time = UnixNanos::from(29);
5352        clock
5353            .borrow_mut()
5354            .as_any_mut()
5355            .downcast_mut::<VirtualClock>()
5356            .unwrap()
5357            .advance_time(release_time, true);
5358        let _risk_events = register_risk_event_handler("RiskEngine.process.release_command");
5359        let risk_commands =
5360            register_risk_command_handler("RiskEngine.queue_execute.release_command");
5361        let exec_algorithm_id = ExecAlgorithmId::from("ALG-RELEASE");
5362        let endpoint = Ustr::from("ALG-RELEASE.execute");
5363        let (handler, algo_commands) = get_any_saving_handler::<TradingCommand>(Some(endpoint));
5364        msgbus::register_any(endpoint.into(), handler);
5365        add_instrument_to_cache(&cache, &instrument);
5366        let trigger_instrument = btcusd_bybit();
5367        add_instrument_to_cache(&cache, &trigger_instrument);
5368        let mut builder = OrderTestBuilder::new(order_type);
5369        builder
5370            .instrument_id(instrument.id())
5371            .trigger_instrument_id(trigger_instrument.id())
5372            .side(OrderSide::Buy)
5373            .price(Price::from("5099.00"))
5374            .trigger_price(Price::from("5100.00"))
5375            .quantity(Quantity::from(3))
5376            .ts_init(UnixNanos::from(11))
5377            .time_in_force(time_in_force)
5378            .reduce_only(true)
5379            .quote_quantity(true)
5380            .tags(vec![Ustr::from("release-tag")])
5381            .emulation_trigger(TriggerType::BidAsk);
5382
5383        if order_type == OrderType::StopLimit {
5384            builder.post_only(true).display_qty(Quantity::from(1));
5385        }
5386
5387        if time_in_force == TimeInForce::Gtd {
5388            builder.expire_time(UnixNanos::from(1_000_000_000_000));
5389        }
5390
5391        if use_algorithm {
5392            builder
5393                .exec_algorithm_id(exec_algorithm_id)
5394                .exec_algorithm_params(
5395                    [(Ustr::from("release-algo-param"), Ustr::from("preserved"))].into(),
5396                )
5397                .exec_spawn_id(ClientOrderId::from("O-SPAWN-RELEASE"));
5398        }
5399
5400        let mut order = builder.build();
5401        let client_order_id = order.client_order_id();
5402        let mut command = create_submit_order(&instrument, &order);
5403        command.client_id = Some(ClientId::from("EXECUTION-RELEASE"));
5404        command.position_id = Some(PositionId::from("P-RELEASE"));
5405        command.exec_algorithm_id = order.exec_algorithm_id();
5406        let params = Params::new([("release-param".to_string(), "preserved".into())].into());
5407        command.params = Some(params);
5408        command.ts_init = UnixNanos::from(123);
5409        command.correlation_id = Some(UUID4::new());
5410        command.causation_id = Some(UUID4::new());
5411        let original_command = command.clone();
5412        cache
5413            .borrow_mut()
5414            .add_order(order.clone(), command.position_id, command.client_id, false)
5415            .unwrap();
5416
5417        emulator.borrow_mut().handle_submit_order(&command);
5418        emulator
5419            .borrow_mut()
5420            .update_order(&mut order, Quantity::from(2));
5421        emulator.borrow_mut().on_quote_tick(create_quote_tick(
5422            &trigger_instrument,
5423            "5100.00",
5424            "5101.00",
5425        ));
5426
5427        let risk_commands = risk_commands.get_messages();
5428        let algo_commands = algo_commands.get_messages();
5429        let (commands, other_commands) = if use_algorithm {
5430            (&algo_commands, &risk_commands)
5431        } else {
5432            (&risk_commands, &algo_commands)
5433        };
5434
5435        let [TradingCommand::SubmitOrder(released_command)] = commands.as_slice() else {
5436            panic!("expected one released SubmitOrder, was {commands:?}");
5437        };
5438
5439        let cache = cache.borrow();
5440        let cached_order = cache.order(&client_order_id).unwrap();
5441        let events = cached_order.events();
5442        let mut expected_command = original_command;
5443        let expected_init = &mut expected_command.order_init;
5444        expected_init.order_type = released_type;
5445        expected_init.quantity = Quantity::from(2);
5446        expected_init.time_in_force = released_time_in_force;
5447        expected_init.trigger_price = None;
5448        expected_init.trigger_type = None;
5449        expected_init.emulation_trigger = None;
5450        expected_init.event_id = released_command.order_init.event_id;
5451        expected_init.ts_event = release_time;
5452        expected_init.ts_init = release_time;
5453        if released_type == OrderType::Market {
5454            expected_init.price = None;
5455            expected_init.expire_time = None;
5456            expected_init.trigger_instrument_id = None;
5457        }
5458
5459        assert_eq!(cached_order.status(), OrderStatus::Released);
5460        assert_eq!(
5461            events[events.len() - 2],
5462            &OrderEventAny::Initialized(released_command.order_init.clone()),
5463        );
5464        assert_eq!(released_command, &expected_command);
5465        assert_eq!(
5466            OrderInitialized::from(&*cached_order),
5467            expected_command.order_init
5468        );
5469        assert!(other_commands.is_empty());
5470    }
5471
5472    #[rstest]
5473    fn test_quote_tick_updates_matching_core_prices(instrument: CryptoPerpetual) {
5474        let (_clock, cache, emulator) = create_emulator();
5475        add_instrument_to_cache(&cache, &instrument);
5476        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
5477        let command = create_submit_order(&instrument, &order);
5478        cache
5479            .borrow_mut()
5480            .add_order(order, None, None, false)
5481            .unwrap();
5482        emulator
5483            .borrow_mut()
5484            .cache_submit_order_command(command.clone());
5485        emulator.borrow_mut().handle_submit_order(&command);
5486
5487        let quote = create_quote_tick(&instrument, "5060.00", "5070.00");
5488        emulator.borrow_mut().on_quote_tick(quote);
5489
5490        let core = emulator
5491            .borrow()
5492            .get_matching_core(&instrument.id())
5493            .unwrap();
5494        assert_eq!(core.bid, Some(Price::from("5060.00")));
5495        assert_eq!(core.ask, Some(Price::from("5070.00")));
5496    }
5497
5498    #[rstest]
5499    fn test_trade_tick_updates_matching_core_last_price(
5500        instrument: CryptoPerpetual,
5501        #[values(false, true)] quotes_subscribed: bool,
5502    ) {
5503        let (_clock, cache, emulator) = create_emulator();
5504        add_instrument_to_cache(&cache, &instrument);
5505        let order = create_stop_market_order(&instrument, TriggerType::LastPrice);
5506        let command = create_submit_order(&instrument, &order);
5507        cache
5508            .borrow_mut()
5509            .add_order(order, None, None, false)
5510            .unwrap();
5511        emulator
5512            .borrow_mut()
5513            .cache_submit_order_command(command.clone());
5514        emulator.borrow_mut().handle_submit_order(&command);
5515
5516        let quote = create_quote_tick(&instrument, "5060.00", "5070.00");
5517
5518        if quotes_subscribed {
5519            let order = OrderTestBuilder::new(OrderType::StopMarket)
5520                .instrument_id(instrument.id())
5521                .client_order_id(ClientOrderId::from("O-QUOTES"))
5522                .side(OrderSide::Buy)
5523                .trigger_price(Price::from("5200.00"))
5524                .quantity(Quantity::from(1))
5525                .emulation_trigger(TriggerType::BidAsk)
5526                .build();
5527            submit_to_emulator(&cache, &emulator, &instrument, &order);
5528            emulator.borrow_mut().on_quote_tick(quote);
5529        }
5530
5531        let trade = create_trade_tick(&instrument, "5065.00");
5532        emulator.borrow_mut().on_trade_tick(trade);
5533
5534        let core = emulator
5535            .borrow()
5536            .get_matching_core(&instrument.id())
5537            .unwrap();
5538        assert_eq!(core.last, Some(Price::from("5065.00")));
5539        assert_eq!(core.bid, quotes_subscribed.then_some(quote.bid_price));
5540        assert_eq!(core.ask, quotes_subscribed.then_some(quote.ask_price));
5541    }
5542
5543    #[rstest]
5544    fn test_cancel_order_removes_from_matching_core(instrument: CryptoPerpetual) {
5545        let (_clock, cache, emulator) = create_emulator();
5546        add_instrument_to_cache(&cache, &instrument);
5547        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
5548        let command = create_submit_order(&instrument, &order);
5549        cache
5550            .borrow_mut()
5551            .add_order(order.clone(), None, None, false)
5552            .unwrap();
5553        emulator
5554            .borrow_mut()
5555            .cache_submit_order_command(command.clone());
5556        emulator.borrow_mut().handle_submit_order(&command);
5557
5558        emulator.borrow_mut().cancel_order(&order);
5559
5560        let core = emulator
5561            .borrow()
5562            .get_matching_core(&instrument.id())
5563            .unwrap();
5564        assert!(core.get_orders().is_empty());
5565    }
5566
5567    #[rstest]
5568    fn test_cancel_order_removes_cached_command(instrument: CryptoPerpetual) {
5569        let (_clock, cache, emulator) = create_emulator();
5570        add_instrument_to_cache(&cache, &instrument);
5571        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
5572        let client_order_id = order.client_order_id();
5573        let command = create_submit_order(&instrument, &order);
5574        cache
5575            .borrow_mut()
5576            .add_order(order.clone(), None, None, false)
5577            .unwrap();
5578        emulator
5579            .borrow_mut()
5580            .cache_submit_order_command(command.clone());
5581        emulator.borrow_mut().handle_submit_order(&command);
5582
5583        emulator.borrow_mut().cancel_order(&order);
5584
5585        let commands = emulator.borrow().get_submit_order_commands();
5586        assert!(!commands.contains_key(&client_order_id));
5587    }
5588
5589    #[rstest]
5590    fn test_cancel_order_after_release_forwards_to_execution_engine(instrument: CryptoPerpetual) {
5591        let (_clock, cache, emulator) = create_emulator();
5592        let _risk_events = register_risk_event_handler("RiskEngine.process.released_cancel");
5593        let _risk_commands =
5594            register_risk_command_handler("RiskEngine.queue_execute.released_cancel");
5595        let (exec_handler, exec_commands) = get_typed_into_message_saving_handler::<TradingCommand>(
5596            Some(Ustr::from("ExecutionEngine.queue_execute.released_cancel")),
5597        );
5598        msgbus::register_trading_command_endpoint(
5599            MessagingSwitchboard::exec_engine_queue_execute(),
5600            exec_handler,
5601        );
5602        add_instrument_to_cache(&cache, &instrument);
5603        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
5604        let client_order_id = order.client_order_id();
5605        let strategy_id = order.strategy_id();
5606        let instrument_id = order.instrument_id();
5607        submit_to_emulator(&cache, &emulator, &instrument, &order);
5608        emulator
5609            .borrow_mut()
5610            .on_quote_tick(create_quote_tick(&instrument, "5099.00", "5101.00"));
5611        let released_order = cache.borrow().order_owned(&client_order_id).unwrap();
5612        assert_eq!(released_order.status(), OrderStatus::Released);
5613
5614        let account_id = AccountId::from("ACCOUNT-001");
5615        let submitted = TestOrderEventStubs::submitted(&released_order, account_id);
5616        cache.borrow_mut().update_order(&submitted).unwrap();
5617        let accepted = TestOrderEventStubs::accepted(
5618            &released_order,
5619            account_id,
5620            VenueOrderId::from("V-RELEASED"),
5621        );
5622        cache.borrow_mut().update_order(&accepted).unwrap();
5623        let accepted_order = cache.borrow().order_owned(&client_order_id).unwrap();
5624        assert_eq!(accepted_order.status(), OrderStatus::Accepted);
5625
5626        let cancel = CancelOrder::new(
5627            accepted_order.trader_id(),
5628            None,
5629            strategy_id,
5630            instrument_id,
5631            client_order_id,
5632            accepted_order.venue_order_id(),
5633            UUID4::new(),
5634            UnixNanos::from(31),
5635            None,
5636            None,
5637        );
5638
5639        let (order_handler, order_events) = subscribe_order_topic(strategy_id);
5640        let (cancel_handler, cancel_events) = subscribe_order_cancel_topic(instrument_id);
5641
5642        emulator.borrow_mut().handle_cancel_order(cancel.clone());
5643        msgbus::unsubscribe_order_events(get_event_order_topic(strategy_id).into(), &order_handler);
5644        msgbus::unsubscribe_order_events(
5645            get_order_canceled_topic(instrument_id).into(),
5646            &cancel_handler,
5647        );
5648        let cached_order = cache.borrow().order_owned(&client_order_id).unwrap();
5649        let exec_commands = exec_commands.get_messages();
5650
5651        assert_eq!(cached_order.status(), OrderStatus::Accepted);
5652        assert_eq!(
5653            exec_commands,
5654            [TradingCommand::CancelOrder(cancel)],
5655            "forwarded commands"
5656        );
5657        assert!(order_events.borrow().is_empty());
5658        assert!(cancel_events.borrow().is_empty());
5659    }
5660
5661    #[rstest]
5662    fn test_trailing_stop_waits_for_activation_price(instrument: CryptoPerpetual) {
5663        let (_clock, cache, emulator) = create_emulator();
5664        let risk_events = register_risk_event_handler("RiskEngine.process.trailing_activation");
5665        let (handler, risk_commands): (_, TypedIntoMessageSavingHandler<TradingCommand>) =
5666            get_typed_into_message_saving_handler(Some(Ustr::from("RiskEngine.queue_execute")));
5667        msgbus::register_trading_command_endpoint(
5668            MessagingSwitchboard::risk_engine_queue_execute(),
5669            handler,
5670        );
5671        add_instrument_to_cache(&cache, &instrument);
5672
5673        let mut core = OrderMatchingCore::new(instrument.id(), instrument.price_increment());
5674        core.set_bid_raw(Price::from("5000.00"));
5675        core.set_ask_raw(Price::from("5001.00"));
5676        emulator
5677            .borrow_mut()
5678            .matching_cores
5679            .insert(instrument.id(), core);
5680
5681        let order = OrderTestBuilder::new(OrderType::TrailingStopMarket)
5682            .instrument_id(instrument.id())
5683            .client_order_id(ClientOrderId::from("O-TRAILING-1"))
5684            .side(OrderSide::Sell)
5685            .quantity(Quantity::from(1))
5686            .activation_price(Price::from("5050.00"))
5687            .trailing_offset(dec!(10))
5688            .trailing_offset_type(TrailingOffsetType::Price)
5689            .emulation_trigger(TriggerType::BidAsk)
5690            .build();
5691        let client_order_id = order.client_order_id();
5692        let command = create_submit_order(&instrument, &order);
5693        cache
5694            .borrow_mut()
5695            .add_order(order, None, None, false)
5696            .unwrap();
5697
5698        emulator
5699            .borrow_mut()
5700            .cache_submit_order_command(command.clone());
5701        emulator.borrow_mut().handle_submit_order(&command);
5702
5703        {
5704            let cache = cache.borrow();
5705            let cached = cache.order(&client_order_id).unwrap();
5706            let is_activated = match &*cached {
5707                OrderAny::TrailingStopMarket(o) => o.is_activated,
5708                _ => panic!("expected trailing stop market order"),
5709            };
5710            assert!(
5711                !is_activated,
5712                "must not activate before the activation price trades"
5713            );
5714            assert!(cached.trigger_price().is_none());
5715        }
5716        assert!(
5717            !risk_events
5718                .get_messages()
5719                .iter()
5720                .any(|e| matches!(e, OrderEventAny::Updated(_))),
5721            "no trailing update before activation"
5722        );
5723
5724        // Market rallies through the 5050 activation price: activates and starts trailing
5725        emulator
5726            .borrow_mut()
5727            .on_quote_tick(create_quote_tick(&instrument, "5055.00", "5056.00"));
5728
5729        {
5730            let cache = cache.borrow();
5731            let cached = cache.order(&client_order_id).unwrap();
5732            let is_activated = match &*cached {
5733                OrderAny::TrailingStopMarket(o) => o.is_activated,
5734                _ => panic!("expected trailing stop market order"),
5735            };
5736            assert!(is_activated);
5737            assert_eq!(cached.trigger_price(), Some(Price::from("5045.00")));
5738        }
5739
5740        assert!(risk_commands.get_messages().is_empty());
5741
5742        // Market falls through the trailed trigger: order releases
5743        emulator
5744            .borrow_mut()
5745            .on_quote_tick(create_quote_tick(&instrument, "5044.00", "5045.00"));
5746
5747        let commands = risk_commands.get_messages();
5748        assert_eq!(commands.len(), 1);
5749        assert!(matches!(
5750            &commands[0],
5751            TradingCommand::SubmitOrder(command) if command.client_order_id == client_order_id
5752        ));
5753    }
5754
5755    #[rstest]
5756    fn test_pending_activation_trailing_stop_limit_not_matched_as_plain_limit(
5757        instrument: CryptoPerpetual,
5758        #[values(false, true)] modified: bool,
5759    ) {
5760        let (_clock, cache, emulator) = create_emulator();
5761        let (handler, risk_commands): (_, TypedIntoMessageSavingHandler<TradingCommand>) =
5762            get_typed_into_message_saving_handler(Some(Ustr::from("RiskEngine.queue_execute")));
5763        msgbus::register_trading_command_endpoint(
5764            MessagingSwitchboard::risk_engine_queue_execute(),
5765            handler,
5766        );
5767        add_instrument_to_cache(&cache, &instrument);
5768
5769        // Market is already through the limit price, but below the activation price
5770        let mut core = OrderMatchingCore::new(instrument.id(), instrument.price_increment());
5771        core.set_bid_raw(Price::from("5000.00"));
5772        core.set_ask_raw(Price::from("5001.00"));
5773        emulator
5774            .borrow_mut()
5775            .matching_cores
5776            .insert(instrument.id(), core);
5777
5778        let order = OrderTestBuilder::new(OrderType::TrailingStopLimit)
5779            .instrument_id(instrument.id())
5780            .client_order_id(ClientOrderId::from("O-TRAILING-LIMIT-1"))
5781            .side(OrderSide::Sell)
5782            .price(Price::from("4990.00"))
5783            .quantity(Quantity::from(1))
5784            .activation_price(Price::from("5050.00"))
5785            .trailing_offset(dec!(10))
5786            .trailing_offset_type(TrailingOffsetType::Price)
5787            .limit_offset(dec!(5))
5788            .emulation_trigger(TriggerType::BidAsk)
5789            .build();
5790        let client_order_id = order.client_order_id();
5791        let command = create_submit_order(&instrument, &order);
5792        cache
5793            .borrow_mut()
5794            .add_order(order, None, None, false)
5795            .unwrap();
5796
5797        emulator
5798            .borrow_mut()
5799            .cache_submit_order_command(command.clone());
5800        emulator.borrow_mut().handle_submit_order(&command);
5801
5802        let trigger_price = modified.then(|| Price::from("4995.00"));
5803
5804        if modified {
5805            let modify = ModifyOrder::new(
5806                command.trader_id,
5807                None,
5808                command.strategy_id,
5809                instrument.id(),
5810                client_order_id,
5811                None,
5812                None,
5813                None,
5814                trigger_price,
5815                UUID4::new(),
5816                0.into(),
5817                None,
5818                None,
5819            );
5820            emulator.borrow_mut().handle_modify_order(&modify);
5821        }
5822
5823        // The market falls below where the trailed trigger would sit (4990)
5824        // while staying below the 5050 activation price: must not release.
5825        emulator
5826            .borrow_mut()
5827            .on_quote_tick(create_quote_tick(&instrument, "4985.00", "4986.00"));
5828
5829        assert!(risk_commands.get_messages().is_empty());
5830        assert!(
5831            emulator
5832                .borrow()
5833                .get_submit_order_commands()
5834                .contains_key(&client_order_id),
5835            "order must remain held by the emulator before activation"
5836        );
5837        assert_eq!(
5838            cache
5839                .borrow()
5840                .order(&client_order_id)
5841                .unwrap()
5842                .trigger_price(),
5843            trigger_price
5844        );
5845    }
5846
5847    #[rstest]
5848    fn test_trailing_stop_with_preset_trigger_activates_and_triggers(instrument: CryptoPerpetual) {
5849        let (_clock, cache, emulator) = create_emulator();
5850        let (handler, risk_commands): (_, TypedIntoMessageSavingHandler<TradingCommand>) =
5851            get_typed_into_message_saving_handler(Some(Ustr::from("RiskEngine.queue_execute")));
5852        msgbus::register_trading_command_endpoint(
5853            MessagingSwitchboard::risk_engine_queue_execute(),
5854            handler,
5855        );
5856        add_instrument_to_cache(&cache, &instrument);
5857
5858        let mut core = OrderMatchingCore::new(instrument.id(), instrument.price_increment());
5859        core.set_bid_raw(Price::from("5000.00"));
5860        core.set_ask_raw(Price::from("5001.00"));
5861        emulator
5862            .borrow_mut()
5863            .matching_cores
5864            .insert(instrument.id(), core);
5865
5866        // Both prices preset: the 5045 trigger must stay inert until 5050 activates
5867        let order = OrderTestBuilder::new(OrderType::TrailingStopMarket)
5868            .instrument_id(instrument.id())
5869            .client_order_id(ClientOrderId::from("O-TRAILING-2"))
5870            .side(OrderSide::Sell)
5871            .quantity(Quantity::from(1))
5872            .trigger_price(Price::from("5045.00"))
5873            .activation_price(Price::from("5050.00"))
5874            .trailing_offset(dec!(10))
5875            .trailing_offset_type(TrailingOffsetType::Price)
5876            .emulation_trigger(TriggerType::BidAsk)
5877            .build();
5878        let client_order_id = order.client_order_id();
5879        let command = create_submit_order(&instrument, &order);
5880        cache
5881            .borrow_mut()
5882            .add_order(order, None, None, false)
5883            .unwrap();
5884
5885        emulator
5886            .borrow_mut()
5887            .cache_submit_order_command(command.clone());
5888        emulator.borrow_mut().handle_submit_order(&command);
5889
5890        assert!(
5891            risk_commands.get_messages().is_empty(),
5892            "preset trigger must not release before activation"
5893        );
5894
5895        // Rally touches the 5050 activation price; the trailed candidate does
5896        // not improve on the preset trigger, so no price update is emitted.
5897        emulator
5898            .borrow_mut()
5899            .on_quote_tick(create_quote_tick(&instrument, "5055.00", "5056.00"));
5900
5901        assert!(risk_commands.get_messages().is_empty());
5902
5903        // Bid falls through the preset trigger: the order must release
5904        emulator
5905            .borrow_mut()
5906            .on_quote_tick(create_quote_tick(&instrument, "5044.00", "5045.00"));
5907
5908        let commands = risk_commands.get_messages();
5909        assert_eq!(commands.len(), 1);
5910        assert!(matches!(
5911            &commands[0],
5912            TradingCommand::SubmitOrder(command) if command.client_order_id == client_order_id
5913        ));
5914    }
5915
5916    #[rstest]
5917    fn test_trailing_stop_activates_despite_trailing_calculate_error(instrument: CryptoPerpetual) {
5918        let (_clock, cache, emulator) = create_emulator();
5919        let (handler, risk_commands): (_, TypedIntoMessageSavingHandler<TradingCommand>) =
5920            get_typed_into_message_saving_handler(Some(Ustr::from("RiskEngine.queue_execute")));
5921        msgbus::register_trading_command_endpoint(
5922            MessagingSwitchboard::risk_engine_queue_execute(),
5923            handler,
5924        );
5925        add_instrument_to_cache(&cache, &instrument);
5926
5927        // Quote-only data: `LastOrBidAsk` trailing calculation errors without a last
5928        let mut core = OrderMatchingCore::new(instrument.id(), instrument.price_increment());
5929        core.set_bid_raw(Price::from("5000.00"));
5930        core.set_ask_raw(Price::from("5001.00"));
5931        emulator
5932            .borrow_mut()
5933            .matching_cores
5934            .insert(instrument.id(), core);
5935
5936        let order = OrderTestBuilder::new(OrderType::TrailingStopMarket)
5937            .instrument_id(instrument.id())
5938            .client_order_id(ClientOrderId::from("O-TRAILING-3"))
5939            .side(OrderSide::Sell)
5940            .quantity(Quantity::from(1))
5941            .trigger_price(Price::from("5045.00"))
5942            .trigger_type(TriggerType::LastOrBidAsk)
5943            .activation_price(Price::from("5050.00"))
5944            .trailing_offset(dec!(10))
5945            .trailing_offset_type(TrailingOffsetType::Price)
5946            .emulation_trigger(TriggerType::BidAsk)
5947            .build();
5948        let client_order_id = order.client_order_id();
5949        let command = create_submit_order(&instrument, &order);
5950        cache
5951            .borrow_mut()
5952            .add_order(order, None, None, false)
5953            .unwrap();
5954
5955        emulator
5956            .borrow_mut()
5957            .cache_submit_order_command(command.clone());
5958        emulator.borrow_mut().handle_submit_order(&command);
5959
5960        // Activation touches while the trailing calculation errors: the preset
5961        // trigger must still be honored once the market crosses it.
5962        emulator
5963            .borrow_mut()
5964            .on_quote_tick(create_quote_tick(&instrument, "5055.00", "5056.00"));
5965        emulator
5966            .borrow_mut()
5967            .on_quote_tick(create_quote_tick(&instrument, "5044.00", "5045.00"));
5968
5969        let commands = risk_commands.get_messages();
5970        assert_eq!(commands.len(), 1);
5971        assert!(matches!(
5972            &commands[0],
5973            TradingCommand::SubmitOrder(command) if command.client_order_id == client_order_id
5974        ));
5975    }
5976
5977    #[rstest]
5978    fn test_basis_point_trailing_stop_limit_releases_on_price_increment(
5979        mut instrument: CryptoPerpetual,
5980    ) {
5981        instrument.price_increment = Price::from("0.25");
5982        let (_clock, cache, emulator) = create_emulator();
5983        let (handler, risk_commands): (_, TypedIntoMessageSavingHandler<TradingCommand>) =
5984            get_typed_into_message_saving_handler(Some(Ustr::from("RiskEngine.queue_execute")));
5985        msgbus::register_trading_command_endpoint(
5986            MessagingSwitchboard::risk_engine_queue_execute(),
5987            handler,
5988        );
5989        add_instrument_to_cache(&cache, &instrument);
5990
5991        let mut core = OrderMatchingCore::new(instrument.id(), instrument.price_increment());
5992        core.set_bid_raw(Price::from("1500.00"));
5993        core.set_ask_raw(Price::from("1500.25"));
5994        emulator
5995            .borrow_mut()
5996            .matching_cores
5997            .insert(instrument.id(), core);
5998
5999        let order = OrderTestBuilder::new(OrderType::TrailingStopLimit)
6000            .instrument_id(instrument.id())
6001            .client_order_id(ClientOrderId::from("O-TRAILING-LIMIT-BPS"))
6002            .side(OrderSide::Sell)
6003            .quantity(Quantity::from(1))
6004            .trigger_type(TriggerType::BidAsk)
6005            .trailing_offset(dec!(33))
6006            .limit_offset(dec!(37))
6007            .trailing_offset_type(TrailingOffsetType::BasisPoints)
6008            .emulation_trigger(TriggerType::BidAsk)
6009            .build();
6010        let client_order_id = order.client_order_id();
6011        let command = create_submit_order(&instrument, &order);
6012        cache
6013            .borrow_mut()
6014            .add_order(order, None, None, false)
6015            .unwrap();
6016
6017        emulator
6018            .borrow_mut()
6019            .cache_submit_order_command(command.clone());
6020        emulator.borrow_mut().handle_submit_order(&command);
6021        emulator
6022            .borrow_mut()
6023            .on_quote_tick(create_quote_tick(&instrument, "1500.00", "1500.25"));
6024
6025        // From the 1500.00 bid, 33 bps is 1495.05 and 37 bps is 1494.45, both between increments
6026        let trailed_trigger = cache
6027            .borrow()
6028            .order(&client_order_id)
6029            .unwrap()
6030            .trigger_price();
6031        let trailed_price = cache.borrow().order(&client_order_id).unwrap().price();
6032
6033        emulator
6034            .borrow_mut()
6035            .on_quote_tick(create_quote_tick(&instrument, "1494.00", "1494.25"));
6036
6037        assert_eq!(trailed_trigger, Some(Price::from("1495.00")));
6038        assert_eq!(trailed_price, Some(Price::from("1494.50")));
6039        let commands = risk_commands.get_messages();
6040
6041        let [TradingCommand::SubmitOrder(released)] = commands.as_slice() else {
6042            panic!("expected one released SubmitOrder, was {commands:?}");
6043        };
6044
6045        assert_eq!(released.client_order_id, client_order_id);
6046        let cache = cache.borrow();
6047        let released_order = cache.order(&client_order_id).unwrap();
6048        assert_eq!(released_order.order_type(), OrderType::Limit);
6049        assert_eq!(released_order.price(), Some(Price::from("1494.50")));
6050    }
6051
6052    #[rstest]
6053    fn test_trailing_stop_limit_without_limit_price_triggered_after_submit(
6054        instrument: CryptoPerpetual,
6055    ) {
6056        let (_clock, cache, emulator) = create_emulator();
6057        let (handler, risk_commands): (_, TypedIntoMessageSavingHandler<TradingCommand>) =
6058            get_typed_into_message_saving_handler(Some(Ustr::from("RiskEngine.queue_execute")));
6059        msgbus::register_trading_command_endpoint(
6060            MessagingSwitchboard::risk_engine_queue_execute(),
6061            handler,
6062        );
6063        add_instrument_to_cache(&cache, &instrument);
6064
6065        let mut core = OrderMatchingCore::new(instrument.id(), instrument.price_increment());
6066        core.set_bid_raw(Price::from("5000.00"));
6067        core.set_ask_raw(Price::from("5001.00"));
6068        emulator
6069            .borrow_mut()
6070            .matching_cores
6071            .insert(instrument.id(), core);
6072
6073        let order = OrderTestBuilder::new(OrderType::TrailingStopLimit)
6074            .instrument_id(instrument.id())
6075            .client_order_id(ClientOrderId::from("O-TRAILING-LIMIT-1"))
6076            .side(OrderSide::Sell)
6077            .quantity(Quantity::from(1))
6078            .trigger_price(Price::from("5045.00"))
6079            .trigger_type(TriggerType::LastOrBidAsk)
6080            .activation_price(Price::from("5050.00"))
6081            .trailing_offset(dec!(10))
6082            .limit_offset(dec!(5))
6083            .trailing_offset_type(TrailingOffsetType::Price)
6084            .emulation_trigger(TriggerType::BidAsk)
6085            .build();
6086        let client_order_id = order.client_order_id();
6087        let command = create_submit_order(&instrument, &order);
6088        cache
6089            .borrow_mut()
6090            .add_order(order, None, None, false)
6091            .unwrap();
6092
6093        emulator
6094            .borrow_mut()
6095            .cache_submit_order_command(command.clone());
6096        emulator.borrow_mut().handle_submit_order(&command);
6097
6098        // Quote-only data: activation touches but `LastOrBidAsk` cannot price the limit
6099        // without a last, so the crossed trigger must hold the order rather than release it.
6100        emulator
6101            .borrow_mut()
6102            .on_quote_tick(create_quote_tick(&instrument, "5055.00", "5056.00"));
6103        emulator
6104            .borrow_mut()
6105            .on_quote_tick(create_quote_tick(&instrument, "5044.00", "5045.00"));
6106
6107        let held_price = cache.borrow().order(&client_order_id).unwrap().price();
6108        let held_commands = risk_commands.get_messages().len();
6109
6110        // The first trade prices the limit, and the next update releases it
6111        emulator
6112            .borrow_mut()
6113            .on_trade_tick(create_trade_tick(&instrument, "5044.00"));
6114        emulator
6115            .borrow_mut()
6116            .on_quote_tick(create_quote_tick(&instrument, "5044.00", "5045.00"));
6117
6118        assert_eq!(held_price, None);
6119        assert_eq!(held_commands, 0);
6120        let commands = risk_commands.get_messages();
6121
6122        let [TradingCommand::SubmitOrder(released)] = commands.as_slice() else {
6123            panic!("expected one released SubmitOrder, was {commands:?}");
6124        };
6125
6126        assert_eq!(released.client_order_id, client_order_id);
6127        let cache = cache.borrow();
6128        let released_order = cache.order(&client_order_id).unwrap();
6129        assert_eq!(released_order.order_type(), OrderType::Limit);
6130        assert_eq!(released_order.price(), Some(Price::from("5039.00")));
6131    }
6132
6133    #[rstest]
6134    fn test_trailing_stop_limit_without_limit_price_triggered_by_modify(
6135        instrument: CryptoPerpetual,
6136    ) {
6137        let (_clock, cache, emulator) = create_emulator();
6138        let (handler, risk_commands): (_, TypedIntoMessageSavingHandler<TradingCommand>) =
6139            get_typed_into_message_saving_handler(Some(Ustr::from("RiskEngine.queue_execute")));
6140        msgbus::register_trading_command_endpoint(
6141            MessagingSwitchboard::risk_engine_queue_execute(),
6142            handler,
6143        );
6144        add_instrument_to_cache(&cache, &instrument);
6145
6146        let mut core = OrderMatchingCore::new(instrument.id(), instrument.price_increment());
6147        core.set_bid_raw(Price::from("5000.00"));
6148        core.set_ask_raw(Price::from("5001.00"));
6149        emulator
6150            .borrow_mut()
6151            .matching_cores
6152            .insert(instrument.id(), core);
6153
6154        let order = OrderTestBuilder::new(OrderType::TrailingStopLimit)
6155            .instrument_id(instrument.id())
6156            .client_order_id(ClientOrderId::from("O-TRAILING-LIMIT-2"))
6157            .side(OrderSide::Sell)
6158            .quantity(Quantity::from(1))
6159            .trigger_type(TriggerType::LastOrBidAsk)
6160            .activation_price(Price::from("5050.00"))
6161            .trailing_offset(dec!(10))
6162            .limit_offset(dec!(5))
6163            .trailing_offset_type(TrailingOffsetType::Price)
6164            .emulation_trigger(TriggerType::BidAsk)
6165            .build();
6166        let client_order_id = order.client_order_id();
6167        let command = create_submit_order(&instrument, &order);
6168        cache
6169            .borrow_mut()
6170            .add_order(order.clone(), None, None, false)
6171            .unwrap();
6172
6173        emulator
6174            .borrow_mut()
6175            .cache_submit_order_command(command.clone());
6176        emulator.borrow_mut().handle_submit_order(&command);
6177        let _exec_events =
6178            register_exec_event_handler(cache.clone(), "ExecEngine.process.trailing_modify");
6179        emulator
6180            .borrow_mut()
6181            .on_quote_tick(create_quote_tick(&instrument, "5055.00", "5056.00"));
6182
6183        let modify = ModifyOrder::new(
6184            order.trader_id(),
6185            None,
6186            order.strategy_id(),
6187            instrument.id(),
6188            client_order_id,
6189            None,
6190            None,
6191            None,
6192            Some(Price::from("5060.00")),
6193            UUID4::new(),
6194            0.into(),
6195            None,
6196            None,
6197        );
6198        emulator.borrow_mut().handle_modify_order(&modify);
6199
6200        let held_commands = risk_commands.get_messages().len();
6201        let held_in_core =
6202            emulator.borrow().matching_cores[&instrument.id()].order_exists(client_order_id);
6203
6204        let (held_status, held_trigger, held_price) = {
6205            let cache = cache.borrow();
6206            let held_order = cache.order(&client_order_id).unwrap();
6207            (
6208                held_order.status(),
6209                held_order.trigger_price(),
6210                held_order.price(),
6211            )
6212        };
6213
6214        // The first trade prices the limit, and the next update releases it
6215        emulator
6216            .borrow_mut()
6217            .on_trade_tick(create_trade_tick(&instrument, "5055.00"));
6218        emulator
6219            .borrow_mut()
6220            .on_quote_tick(create_quote_tick(&instrument, "5055.00", "5056.00"));
6221
6222        assert_eq!(held_commands, 0);
6223        assert!(held_in_core);
6224        assert_eq!(held_status, OrderStatus::Emulated);
6225        assert_eq!(held_trigger, Some(Price::from("5060.00")));
6226        assert_eq!(held_price, None);
6227        let commands = risk_commands.get_messages();
6228
6229        let [TradingCommand::SubmitOrder(released)] = commands.as_slice() else {
6230            panic!("expected one released SubmitOrder, was {commands:?}");
6231        };
6232
6233        assert_eq!(released.client_order_id, client_order_id);
6234        let cache = cache.borrow();
6235        let released_order = cache.order(&client_order_id).unwrap();
6236        assert_eq!(released_order.order_type(), OrderType::Limit);
6237        assert_eq!(released_order.price(), Some(Price::from("5050.00")));
6238    }
6239
6240    #[rstest]
6241    fn test_cancel_emulated_oco_leg_cancels_sibling(instrument: CryptoPerpetual) {
6242        let (_clock, cache, emulator) = create_emulator();
6243        add_instrument_to_cache(&cache, &instrument);
6244        let client_order_id_a = ClientOrderId::from("O-OCO-A");
6245        let client_order_id_b = ClientOrderId::from("O-OCO-B");
6246        let order_a = OrderTestBuilder::new(OrderType::StopMarket)
6247            .instrument_id(instrument.id())
6248            .strategy_id(StrategyId::from("STRATEGY-001"))
6249            .client_order_id(client_order_id_a)
6250            .side(OrderSide::Sell)
6251            .trigger_price(Price::from("4900.00"))
6252            .quantity(Quantity::from(1))
6253            .emulation_trigger(TriggerType::BidAsk)
6254            .contingency_type(ContingencyType::Oco)
6255            .linked_order_ids(vec![client_order_id_b])
6256            .build();
6257        let order_b = OrderTestBuilder::new(OrderType::StopMarket)
6258            .instrument_id(instrument.id())
6259            .strategy_id(StrategyId::from("STRATEGY-001"))
6260            .client_order_id(client_order_id_b)
6261            .side(OrderSide::Sell)
6262            .trigger_price(Price::from("4950.00"))
6263            .quantity(Quantity::from(1))
6264            .emulation_trigger(TriggerType::BidAsk)
6265            .contingency_type(ContingencyType::Oco)
6266            .linked_order_ids(vec![client_order_id_a])
6267            .build();
6268        cache
6269            .borrow_mut()
6270            .add_order(order_a.clone(), None, None, false)
6271            .unwrap();
6272        cache
6273            .borrow_mut()
6274            .add_order(order_b.clone(), None, None, false)
6275            .unwrap();
6276
6277        for order in [&order_a, &order_b] {
6278            let command = create_submit_order(&instrument, order);
6279            emulator
6280                .borrow_mut()
6281                .cache_submit_order_command(command.clone());
6282            emulator.borrow_mut().handle_submit_order(&command);
6283        }
6284        assert_eq!(
6285            cache.borrow().order(&client_order_id_a).unwrap().status(),
6286            OrderStatus::Emulated
6287        );
6288        assert_eq!(
6289            cache.borrow().order(&client_order_id_b).unwrap().status(),
6290            OrderStatus::Emulated
6291        );
6292
6293        let cancel = CancelOrder::new(
6294            order_a.trader_id(),
6295            None,
6296            order_a.strategy_id(),
6297            instrument.id(),
6298            client_order_id_a,
6299            None,
6300            UUID4::new(),
6301            0.into(),
6302            None,
6303            None,
6304        );
6305        msgbus::send_trading_command(
6306            MessagingSwitchboard::order_emulator_execute(),
6307            TradingCommand::CancelOrder(cancel),
6308        );
6309
6310        let cache = cache.borrow();
6311        assert_eq!(
6312            cache.order(&client_order_id_a).unwrap().status(),
6313            OrderStatus::Canceled
6314        );
6315        assert_eq!(
6316            cache.order(&client_order_id_b).unwrap().status(),
6317            OrderStatus::Canceled,
6318            "OCO sibling must be canceled through the deferred self-published event"
6319        );
6320    }
6321
6322    #[rstest]
6323    fn test_reentrant_command_from_event_handler_does_not_panic(instrument: CryptoPerpetual) {
6324        let (_clock, cache, emulator) = create_emulator();
6325        add_instrument_to_cache(&cache, &instrument);
6326        let order = create_stop_market_order(&instrument, TriggerType::BidAsk);
6327        let client_order_id = order.client_order_id();
6328        let strategy_id = order.strategy_id();
6329        let command = create_submit_order(&instrument, &order);
6330        cache
6331            .borrow_mut()
6332            .add_order(order.clone(), None, None, false)
6333            .unwrap();
6334        emulator
6335            .borrow_mut()
6336            .cache_submit_order_command(command.clone());
6337
6338        // A strategy-style subscriber issuing an emulator command synchronously
6339        // from within its own order-event handler.
6340        let cancel = CancelOrder::new(
6341            order.trader_id(),
6342            None,
6343            strategy_id,
6344            instrument.id(),
6345            client_order_id,
6346            None,
6347            UUID4::new(),
6348            0.into(),
6349            None,
6350            None,
6351        );
6352        let handler = TypedHandler::from(move |event: &OrderEventAny| {
6353            if matches!(event, OrderEventAny::Emulated(_)) {
6354                msgbus::send_trading_command(
6355                    MessagingSwitchboard::order_emulator_execute(),
6356                    TradingCommand::CancelOrder(cancel.clone()),
6357                );
6358            }
6359        });
6360        msgbus::subscribe_order_events(format!("events.order.{strategy_id}").into(), handler, None);
6361
6362        // Must not panic on the reentrant borrow; the command is deferred and drained
6363        msgbus::send_trading_command(
6364            MessagingSwitchboard::order_emulator_execute(),
6365            TradingCommand::SubmitOrder(command),
6366        );
6367
6368        assert!(
6369            cache.borrow().order(&client_order_id).unwrap().is_closed(),
6370            "deferred cancel must be processed after the active call completes"
6371        );
6372    }
6373
6374    #[rstest]
6375    fn test_released_order_preserves_chronological_event_history(instrument: CryptoPerpetual) {
6376        let (_clock, cache, emulator) = create_emulator();
6377        add_instrument_to_cache(&cache, &instrument);
6378        let mut core = OrderMatchingCore::new(instrument.id(), instrument.price_increment());
6379        core.set_bid_raw(Price::from("5099.00"));
6380        core.set_ask_raw(Price::from("5101.00"));
6381        emulator
6382            .borrow_mut()
6383            .matching_cores
6384            .insert(instrument.id(), core);
6385
6386        let order = create_stop_limit_order(&instrument, TriggerType::BidAsk);
6387        let client_order_id = order.client_order_id();
6388        let original_init = OrderEventAny::Initialized(order.init_event().clone());
6389        let command = create_submit_order(&instrument, &order);
6390        cache
6391            .borrow_mut()
6392            .add_order(order, None, None, false)
6393            .unwrap();
6394
6395        emulator
6396            .borrow_mut()
6397            .cache_submit_order_command(command.clone());
6398        emulator.borrow_mut().handle_submit_order(&command);
6399
6400        let cache = cache.borrow();
6401        let transformed = cache.order(&client_order_id).unwrap();
6402        let events = transformed.events();
6403
6404        assert_eq!(
6405            events.first(),
6406            Some(&&original_init),
6407            "released order history must start with the original OrderInitialized event, was {events:?}",
6408        );
6409    }
6410
6411    #[rstest]
6412    fn test_on_start_cancels_emulated_child_of_closed_positionless_parent(
6413        instrument: CryptoPerpetual,
6414    ) {
6415        let (_clock, cache, emulator) = create_emulator();
6416        add_instrument_to_cache(&cache, &instrument);
6417
6418        let mut parent = OrderTestBuilder::new(OrderType::Limit)
6419            .instrument_id(instrument.id())
6420            .client_order_id(ClientOrderId::from("O-PARENT"))
6421            .side(OrderSide::Buy)
6422            .price(Price::from("5000.00"))
6423            .quantity(Quantity::from(1))
6424            .submit(true)
6425            .build();
6426        parent
6427            .apply(OrderEventAny::Canceled(OrderCanceled::new(
6428                parent.trader_id(),
6429                parent.strategy_id(),
6430                parent.instrument_id(),
6431                parent.client_order_id(),
6432                UUID4::new(),
6433                0.into(),
6434                0.into(),
6435                false,
6436                None,
6437                None,
6438                None,
6439            )))
6440            .unwrap();
6441        assert!(parent.is_closed());
6442        assert!(parent.position_id().is_none());
6443
6444        let mut child = OrderTestBuilder::new(OrderType::StopMarket)
6445            .instrument_id(instrument.id())
6446            .client_order_id(ClientOrderId::from("O-CHILD"))
6447            .side(OrderSide::Sell)
6448            .trigger_price(Price::from("4900.00"))
6449            .quantity(Quantity::from(1))
6450            .emulation_trigger(TriggerType::BidAsk)
6451            .parent_order_id(parent.client_order_id())
6452            .build();
6453        child
6454            .apply(OrderEventAny::Emulated(OrderEmulated::new(
6455                child.trader_id(),
6456                child.strategy_id(),
6457                child.instrument_id(),
6458                child.client_order_id(),
6459                UUID4::new(),
6460                0.into(),
6461                0.into(),
6462            )))
6463            .unwrap();
6464        assert_eq!(child.status(), OrderStatus::Emulated);
6465
6466        cache
6467            .borrow_mut()
6468            .add_order(parent.clone(), None, None, false)
6469            .unwrap();
6470        cache
6471            .borrow_mut()
6472            .add_order(child.clone(), None, None, false)
6473            .unwrap();
6474
6475        emulator.borrow_mut().on_start().unwrap();
6476
6477        assert!(
6478            cache
6479                .borrow()
6480                .order(&child.client_order_id())
6481                .unwrap()
6482                .is_closed(),
6483            "emulated child of a closed position-less parent must be canceled on reactivation"
6484        );
6485    }
6486}