1use 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 pub fn cache_submit_order_command(&mut self, command: SubmitOrder) {
162 self.manager.cache_submit_order_command(command);
163 }
164
165 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 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 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; }
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; }
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; }
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, UUID4::new(),
370 self.clock.borrow().timestamp_ns(),
371 None, );
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 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 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 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 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 }
607
608 self.check_monitoring(strategy_id, position_id);
609
610 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 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 if !self
637 .manager
638 .get_submit_order_commands()
639 .contains_key(&order.client_order_id())
640 {
641 return; }
643
644 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 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 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; }
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 self.apply_order_event(&event);
816
817 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 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 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 = "e.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 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 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 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 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 pub fn fill_limit_order(&mut self, client_order_id: ClientOrderId) {
1240 self.release_order(client_order_id, ReleaseType::Limit);
1241 }
1242
1243 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 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 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 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 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 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; }
1574
1575 if !was_activated {
1576 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 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 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 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, )
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()), "e);
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()), "e);
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, "e_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("e_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()), "e);
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 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, "e_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("e_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("e_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, "e_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 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 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 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, "e_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, "e_order);
5243 submit_to_emulator(&cache, &emulator, &instrument, &trailing_order);
5244
5245 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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}