1use std::num::NonZeroUsize;
17
18use ahash::AHashSet;
19use nautilus_common::{
20 actor::{DataActor, DataActorNative},
21 config::ConfigError,
22 enums::LogColor,
23 log_info, log_warn,
24};
25use nautilus_core::{DurationNanos, UnixNanos};
26use nautilus_model::{
27 data::{Bar, IndexPriceUpdate, MarkPriceUpdate, OrderBookDeltas, QuoteTick, TradeTick},
28 enums::{ContingencyType, OrderSide, OrderStatus, OrderType, TimeInForce},
29 events::{
30 OrderAccepted, OrderCancelDenied, OrderCancelRejected, OrderCanceled, OrderDenied,
31 OrderEvent, OrderEventAny, OrderExpired, OrderFilled, OrderModifyDenied,
32 OrderModifyRejected, OrderRejected, OrderUpdated,
33 },
34 identifiers::{ClientId, ClientOrderId, InstrumentId, StrategyId},
35 instruments::{Instrument, InstrumentAny},
36 orderbook::OrderBook,
37 orders::{Order, OrderAny, OrderCore},
38 types::{Price, Quantity},
39};
40use nautilus_trading::{
41 nautilus_strategy,
42 strategy::{Strategy, StrategyCore, StrategyNative},
43};
44use rust_decimal::Decimal;
45
46use super::config::ExecTesterConfig;
47use crate::testers::timestamps::warn_if_implausible_unix_nanos;
48
49#[derive(Debug)]
58#[expect(
59 clippy::struct_excessive_bools,
60 reason = "tester state tracks independent execution scenarios"
61)]
62pub struct ExecTester {
63 pub(super) core: StrategyCore,
64 pub(super) config: ExecTesterConfig,
65 pub(super) instrument: Option<InstrumentAny>,
66 pub(super) price_offset: Option<u64>,
67 pub(super) preinitialized_market_data: bool,
68
69 pub(super) buy_order: Option<OrderAny>,
71 pub(super) sell_order: Option<OrderAny>,
72 pub(super) buy_stop_order: Option<OrderAny>,
73 pub(super) sell_stop_order: Option<OrderAny>,
74 pub(super) open_position_submitted: bool,
75
76 pub(super) modify_rejected_attempted: bool,
79 pub(super) pending_open_position_qty: Option<Decimal>,
80 pub(super) buy_stop_cancel_replace_attempted: bool,
81 pub(super) sell_stop_cancel_replace_attempted: bool,
82 buy_stop_replacement: Option<StopOrderReplacement>,
83 sell_stop_replacement: Option<StopOrderReplacement>,
84 pub(super) buy_limit_maintenance_state: LimitOrderMaintenanceState,
85 pub(super) sell_limit_maintenance_state: LimitOrderMaintenanceState,
86}
87
88#[derive(Debug, Clone, Copy, PartialEq, Eq)]
89pub(super) enum LimitOrderMaintenanceState {
90 Disabled,
91 Ready,
92 AwaitingAcceptance {
93 client_order_id: ClientOrderId,
94 },
95 Active {
96 client_order_id: ClientOrderId,
97 },
98 AwaitingUpdate {
99 client_order_id: ClientOrderId,
100 price: Price,
101 },
102 AwaitingCancel {
103 client_order_id: ClientOrderId,
104 replacement_price: Price,
105 },
106 AwaitingReplacementAcceptance {
107 client_order_id: ClientOrderId,
108 price: Price,
109 },
110 Completed,
111 Failed,
112}
113
114nautilus_strategy!(ExecTester, {
115 fn external_order_instrument_ids(&self) -> Option<Vec<InstrumentId>> {
116 self.core.config.external_order_instrument_ids.clone()
117 }
118
119 fn on_order_accepted(&mut self, event: OrderAccepted) {
120 self.handle_limit_order_accepted(event.client_order_id);
121 }
122
123 fn on_order_updated(&mut self, event: OrderUpdated) {
124 self.handle_limit_order_updated(event.client_order_id, event.price);
125 }
126
127 fn on_order_canceled(&mut self, event: &OrderCanceled) {
128 self.handle_limit_order_canceled(event.client_order_id);
129 self.handle_stop_order_canceled(event);
130 }
131
132 fn on_order_modify_denied(&mut self, event: OrderModifyDenied) {
133 self.finish_limit_order_maintenance(event.client_order_id);
134 }
135
136 fn on_order_modify_rejected(&mut self, event: OrderModifyRejected) {
137 self.finish_limit_order_maintenance(event.client_order_id);
138 }
139
140 fn on_order_cancel_denied(&mut self, event: OrderCancelDenied) {
141 self.finish_limit_order_maintenance(event.client_order_id);
142 self.clear_stop_order_replacement(event.client_order_id);
143 }
144
145 fn on_order_cancel_rejected(&mut self, event: OrderCancelRejected) {
146 self.finish_limit_order_maintenance(event.client_order_id);
147 self.clear_stop_order_replacement(event.client_order_id);
148 }
149
150 fn on_order_denied(&mut self, event: OrderDenied) {
151 self.handle_limit_order_closed(event.client_order_id);
152 self.clear_stop_order_replacement(event.client_order_id);
153 }
154
155 fn on_order_rejected(&mut self, event: OrderRejected) {
156 self.handle_limit_order_closed(event.client_order_id);
157 self.clear_stop_order_replacement(event.client_order_id);
158 }
159
160 fn on_order_expired(&mut self, event: OrderExpired) {
161 self.handle_limit_order_closed(event.client_order_id);
162 self.clear_stop_order_replacement(event.client_order_id);
163 }
164
165 fn on_order_filled(&mut self, event: &OrderFilled) {
166 let (is_closed, is_filled) = self
167 .cache()
168 .order(&event.client_order_id)
169 .map_or((true, false), |order| {
170 (order.is_closed(), order.status() == OrderStatus::Filled)
171 });
172
173 if is_closed {
174 self.handle_limit_order_closed(event.client_order_id);
175 }
176
177 if is_filled {
178 self.clear_stop_order_replacement(event.client_order_id);
179 }
180 }
181
182 fn on_order_event(&mut self, event: OrderEventAny) {
183 let event = event.into_boxed();
184 warn_if_implausible_unix_nanos(
185 "order event",
186 OrderEvent::ts_event(&*event),
187 OrderEvent::ts_init(&*event),
188 );
189 }
190});
191
192impl DataActor for ExecTester {
193 fn on_start(&mut self) -> anyhow::Result<()> {
194 let instrument_id = self.config.instrument_id;
195 let client_id = self.config.client_id;
196
197 let instrument = self.cache().instrument(&instrument_id);
198
199 if let Some(inst) = instrument {
200 self.initialize_with_instrument(inst, true)?;
201 } else {
202 log::info!("Instrument {instrument_id} not in cache, subscribing...");
203 self.subscribe_instrument(instrument_id, client_id, None);
204
205 if self.config.subscribe_quotes {
208 self.subscribe_quotes(instrument_id, client_id, None);
209 }
210
211 if self.config.subscribe_trades {
212 self.subscribe_trades(instrument_id, client_id, None);
213 }
214 self.preinitialized_market_data =
215 self.config.subscribe_quotes || self.config.subscribe_trades;
216 }
217
218 Ok(())
219 }
220
221 fn on_instrument(&mut self, instrument: &InstrumentAny) -> anyhow::Result<()> {
222 warn_if_implausible_unix_nanos("instrument", instrument.ts_event(), instrument.ts_init());
223
224 if instrument.id() == self.config.instrument_id && self.instrument.is_none() {
225 let id = instrument.id();
226 log::info!("Received instrument {id}, initializing...");
227 self.initialize_with_instrument(instrument.clone(), !self.preinitialized_market_data)?;
228 }
229 Ok(())
230 }
231
232 fn on_stop(&mut self) -> anyhow::Result<()> {
233 self.buy_stop_replacement = None;
234 self.sell_stop_replacement = None;
235
236 let instrument_id = self.config.instrument_id;
237 let client_id = self.config.client_id;
238
239 if self.config.dry_run {
240 log_warn!("Dry run mode, skipping cancel all orders and close all positions");
241 } else {
242 let strategy_id = StrategyId::from(
243 DataActorNative::core(&self.core)
244 .actor_id()
245 .inner()
246 .as_str(),
247 );
248
249 if self.config.cancel_orders_on_stop {
250 self.cancel_active_orders(instrument_id, strategy_id, client_id);
251 }
252
253 if self.config.close_positions_on_stop {
254 let time_in_force = self
255 .config
256 .close_positions_time_in_force
257 .or(Some(TimeInForce::Gtc));
258
259 if let Err(e) = self.close_positions_on_stop(strategy_id, time_in_force) {
260 log::error!("Failed to close all positions: {e}");
261 }
262 }
263 }
264
265 if !self.config.can_unsubscribe {
266 return Ok(());
267 }
268
269 self.unsubscribe_instrument(instrument_id, client_id, None);
270 if self.config.subscribe_quotes {
271 self.unsubscribe_quotes(instrument_id, client_id, None);
272 }
273
274 if self.config.subscribe_trades {
275 self.unsubscribe_trades(instrument_id, client_id, None);
276 }
277
278 if self.config.subscribe_book {
279 self.unsubscribe_book_at_interval(
280 instrument_id,
281 NonZeroUsize::new(self.config.book_interval_ms).ok_or_else(|| {
282 ConfigError::range("book_interval_ms", "must be positive, was 0")
283 })?,
284 client_id,
285 None,
286 );
287 }
288
289 Ok(())
290 }
291
292 fn on_quote(&mut self, quote: &QuoteTick) -> anyhow::Result<()> {
293 warn_if_implausible_unix_nanos("quote", quote.ts_event, quote.ts_init);
294
295 if self.config.log_data {
296 log_info!("{quote:?}", color = LogColor::Cyan);
297 }
298
299 if quote.instrument_id == self.config.instrument_id
300 && self.config.open_position_on_first_quote
301 {
302 self.submit_pending_open_position();
303 }
304
305 self.maintain_orders(quote.bid_price, quote.ask_price);
306 Ok(())
307 }
308
309 fn on_trade(&mut self, trade: &TradeTick) -> anyhow::Result<()> {
310 warn_if_implausible_unix_nanos("trade", trade.ts_event, trade.ts_init);
311
312 if self.config.log_data {
313 log_info!("{trade:?}", color = LogColor::Cyan);
314 }
315 Ok(())
316 }
317
318 fn on_book(&mut self, book: &OrderBook) -> anyhow::Result<()> {
319 if self.config.log_data {
320 let num_levels = self.config.book_levels_to_print;
321 let instrument_id = book.instrument_id;
322 let book_str = book.pprint(num_levels, None);
323 log_info!("\n{instrument_id}\n{book_str}", color = LogColor::Cyan);
324
325 if DataActorNative::core(&self.core).is_registered() {
327 let cache = self.cache();
328 if let Some(own_book) = cache.own_order_book(&instrument_id) {
329 let own_book_str = own_book.pprint(num_levels, None);
330 log_info!(
331 "\n{instrument_id} (own)\n{own_book_str}",
332 color = LogColor::Magenta
333 );
334 }
335 }
336 }
337
338 let Some(best_bid) = book.best_bid_price() else {
339 return Ok(()); };
341 let Some(best_ask) = book.best_ask_price() else {
342 return Ok(()); };
344
345 self.maintain_orders(best_bid, best_ask);
346 Ok(())
347 }
348
349 fn on_book_deltas(&mut self, deltas: &OrderBookDeltas) -> anyhow::Result<()> {
350 warn_if_implausible_unix_nanos("book deltas", deltas.ts_event, deltas.ts_init);
351
352 if self.config.log_data {
353 log_info!("{deltas:?}", color = LogColor::Cyan);
354 }
355 Ok(())
356 }
357
358 fn on_bar(&mut self, bar: &Bar) -> anyhow::Result<()> {
359 warn_if_implausible_unix_nanos("bar", bar.ts_event, bar.ts_init);
360
361 if self.config.log_data {
362 log_info!("{bar:?}", color = LogColor::Cyan);
363 }
364 Ok(())
365 }
366
367 fn on_mark_price(&mut self, mark_price: &MarkPriceUpdate) -> anyhow::Result<()> {
368 warn_if_implausible_unix_nanos("mark price", mark_price.ts_event, mark_price.ts_init);
369
370 if self.config.log_data {
371 log_info!("{mark_price:?}", color = LogColor::Cyan);
372 }
373 Ok(())
374 }
375
376 fn on_index_price(&mut self, index_price: &IndexPriceUpdate) -> anyhow::Result<()> {
377 warn_if_implausible_unix_nanos("index price", index_price.ts_event, index_price.ts_init);
378
379 if self.config.log_data {
380 log_info!("{index_price:?}", color = LogColor::Cyan);
381 }
382 Ok(())
383 }
384}
385
386impl ExecTester {
387 #[must_use]
389 pub fn new(config: ExecTesterConfig) -> Self {
390 let pending_open_position_qty = config.open_position_on_start_qty;
391 let buy_limit_maintenance_state = LimitOrderMaintenanceState::new(
392 config.enable_limit_buys
393 && (config.trigger_limit_order_maintenance_once
394 || config.cancel_replace_orders_to_maintain_tob_offset),
395 );
396 let sell_limit_maintenance_state = LimitOrderMaintenanceState::new(
397 config.enable_limit_sells
398 && (config.trigger_limit_order_maintenance_once
399 || config.cancel_replace_orders_to_maintain_tob_offset),
400 );
401
402 Self {
403 core: StrategyCore::new(config.base.clone()),
404 config,
405 instrument: None,
406 price_offset: None,
407 preinitialized_market_data: false,
408 buy_order: None,
409 sell_order: None,
410 buy_stop_order: None,
411 sell_stop_order: None,
412 open_position_submitted: false,
413 modify_rejected_attempted: false,
414 pending_open_position_qty,
415 buy_stop_cancel_replace_attempted: false,
416 sell_stop_cancel_replace_attempted: false,
417 buy_stop_replacement: None,
418 sell_stop_replacement: None,
419 buy_limit_maintenance_state,
420 sell_limit_maintenance_state,
421 }
422 }
423
424 fn initialize_with_instrument(
425 &mut self,
426 instrument: InstrumentAny,
427 subscribe_market_data: bool,
428 ) -> anyhow::Result<()> {
429 let instrument_id = self.config.instrument_id;
430 let client_id = self.config.client_id;
431
432 self.price_offset = Some(self.get_price_offset(&instrument));
433 self.instrument = Some(instrument);
434
435 if subscribe_market_data && self.config.subscribe_quotes {
436 self.subscribe_quotes(instrument_id, client_id, None);
437 }
438
439 if subscribe_market_data && self.config.subscribe_trades {
440 self.subscribe_trades(instrument_id, client_id, None);
441 }
442
443 if self.config.subscribe_book {
444 self.subscribe_book_at_interval(
445 instrument_id,
446 self.config.book_type,
447 self.config
448 .book_depth
449 .map(|depth| {
450 NonZeroUsize::new(depth).ok_or_else(|| {
451 ConfigError::range("book_depth", "must be positive, was 0")
452 })
453 })
454 .transpose()?,
455 NonZeroUsize::new(self.config.book_interval_ms).ok_or_else(|| {
456 ConfigError::range("book_interval_ms", "must be positive, was 0")
457 })?,
458 client_id,
459 None,
460 );
461 }
462
463 if let Some(qty) = self.pending_open_position_qty {
464 let quote_ready = {
465 let cache = self.cache();
466 cache.quote(&instrument_id).is_some()
467 };
468
469 if self.config.open_position_on_first_quote
470 && self.config.subscribe_quotes
471 && !quote_ready
472 {
473 log::info!("Waiting for first quote before opening {instrument_id} position");
474 } else {
475 self.pending_open_position_qty = None;
476 self.open_position(qty)?;
477 self.open_position_submitted = true;
478 }
479 }
480
481 Ok(())
482 }
483
484 pub(super) fn get_price_offset(&self, _instrument: &InstrumentAny) -> u64 {
485 self.config.tob_offset_ticks
486 }
487
488 fn expire_time_from_delta(&self, mins: u64) -> UnixNanos {
489 let current_ns = DataActorNative::core(&self.core).timestamp_ns();
490 let delta = DurationNanos::try_from_mins(mins).unwrap_or(DurationNanos::MAX);
491 current_ns.saturating_add(delta)
492 }
493
494 fn resolve_time_in_force(
495 &self,
496 tif_override: Option<TimeInForce>,
497 ) -> (TimeInForce, Option<UnixNanos>) {
498 match (tif_override, self.config.order_expire_time_delta_mins) {
499 (Some(TimeInForce::Gtd), Some(mins)) => {
500 (TimeInForce::Gtd, Some(self.expire_time_from_delta(mins)))
501 }
502 (Some(TimeInForce::Gtd), None) => {
503 log_warn!(
504 "GTD time in force requires order_expire_time_delta_mins, falling back to GTC"
505 );
506 (TimeInForce::Gtc, None)
507 }
508 (Some(tif), _) => (tif, None),
509 (None, Some(mins)) => (TimeInForce::Gtd, Some(self.expire_time_from_delta(mins))),
510 (None, None) => (TimeInForce::Gtc, None),
511 }
512 }
513
514 fn submit_pending_open_position(&mut self) {
515 if self.instrument.is_none() {
516 return;
517 }
518
519 let Some(qty) = self.pending_open_position_qty.take() else {
520 return;
521 };
522
523 if let Err(e) = self.open_position(qty) {
524 log::error!("Failed to submit pending open position: {e}");
525 } else {
526 self.open_position_submitted = true;
527 }
528 }
529
530 pub(super) fn is_order_active(order: &OrderAny) -> bool {
531 order.is_active_local() || order.is_inflight() || order.is_open()
532 }
533
534 pub(super) fn limit_order_is_one_shot(&self) -> bool {
535 self.config.test_reject_post_only
536 || self.config.limit_aggressive
537 || self.config.order_expire_time_delta_mins.is_some()
538 || matches!(
539 self.config.limit_time_in_force,
540 Some(TimeInForce::Ioc | TimeInForce::Fok)
541 )
542 }
543
544 pub(super) fn stop_order_is_one_shot(&self) -> bool {
545 self.config.order_expire_time_delta_mins.is_some()
546 || matches!(
547 self.config.stop_time_in_force,
548 Some(TimeInForce::Ioc | TimeInForce::Fok)
549 )
550 || matches!(self.config.stop_order_type, OrderType::TrailingStopMarket)
551 }
552
553 pub(super) fn get_order_trigger_price(order: &OrderAny) -> Option<Price> {
554 order.trigger_price()
555 }
556
557 fn modify_stop_order(
558 &mut self,
559 order: &OrderAny,
560 trigger_price: Price,
561 limit_price: Option<Price>,
562 ) -> anyhow::Result<()> {
563 let client_id = self.config.client_id;
564
565 match order {
566 OrderAny::StopMarket(_)
567 | OrderAny::MarketIfTouched(_)
568 | OrderAny::TrailingStopMarket(_) => self.modify_order(
569 order.client_order_id(),
570 None,
571 None,
572 Some(trigger_price),
573 client_id,
574 None,
575 ),
576 OrderAny::StopLimit(_) | OrderAny::LimitIfTouched(_) => self.modify_order(
577 order.client_order_id(),
578 None,
579 limit_price,
580 Some(trigger_price),
581 client_id,
582 None,
583 ),
584 _ => {
585 log_warn!("Cannot modify order of type {:?}", order.order_type());
586 Ok(())
587 }
588 }
589 }
590
591 fn submit_order_apply_params(&mut self, order: OrderAny) -> anyhow::Result<()> {
593 let client_id = self.config.client_id;
594 if let Some(params) = &self.config.order_params {
595 self.submit_order(order, None, client_id, Some(params.clone()))
596 } else {
597 self.submit_order(order, None, client_id, None)
598 }
599 }
600
601 pub(super) fn maintain_orders(&mut self, best_bid: Price, best_ask: Price) {
603 if self.instrument.is_none() || self.config.dry_run {
604 return;
605 }
606
607 if self.config.batch_submit_limit_pair
608 && self.config.enable_limit_buys
609 && self.config.enable_limit_sells
610 {
611 self.maintain_batch_limit_pair(best_bid, best_ask);
612 return;
613 }
614
615 if self.config.enable_limit_buys {
616 self.maintain_buy_orders(best_bid, best_ask);
617 }
618
619 if self.config.enable_limit_sells {
620 self.maintain_sell_orders(best_bid, best_ask);
621 }
622
623 if self.config.enable_stop_buys {
624 self.maintain_stop_buy_orders(best_bid, best_ask);
625 }
626
627 if self.config.enable_stop_sells {
628 self.maintain_stop_sell_orders(best_bid, best_ask);
629 }
630 }
631
632 fn refresh_tracked_order(&mut self, side: OrderSide) {
636 let cid = match side {
637 OrderSide::Buy => self.buy_order.as_ref().map(OrderAny::client_order_id),
638 OrderSide::Sell => self.sell_order.as_ref().map(OrderAny::client_order_id),
639 };
640 let Some(cid) = cid else {
641 return;
642 };
643 let latest = self.cache().order(&cid);
644 if let Some(latest) = latest {
645 match side {
646 OrderSide::Buy => self.buy_order = Some(latest),
647 OrderSide::Sell => self.sell_order = Some(latest),
648 }
649 }
650 }
651
652 fn refresh_tracked_stop_order(&mut self, side: OrderSide) {
653 let cid = match side {
654 OrderSide::Buy => self.buy_stop_order.as_ref().map(OrderAny::client_order_id),
655 OrderSide::Sell => self.sell_stop_order.as_ref().map(OrderAny::client_order_id),
656 };
657 let Some(cid) = cid else {
658 return;
659 };
660 let latest = self.cache().order(&cid);
661 if let Some(latest) = latest {
662 match side {
663 OrderSide::Buy => self.buy_stop_order = Some(latest),
664 OrderSide::Sell => self.sell_stop_order = Some(latest),
665 }
666 }
667 }
668
669 fn maintain_buy_orders(&mut self, best_bid: Price, best_ask: Price) {
671 self.refresh_tracked_order(OrderSide::Buy);
675
676 let Some(instrument) = &self.instrument else {
677 return;
678 };
679
680 let Some(price) = self.limit_price(OrderSide::Buy, best_bid, best_ask) else {
681 return;
682 };
683
684 let increment = instrument.price_increment();
685 let precision = instrument.price_precision();
686
687 if self.limit_order_maintenance_suppressed(OrderSide::Buy) {
688 return;
689 }
690
691 let needs_new_order = match &self.buy_order {
692 None => true,
693 Some(order) => !Self::is_order_active(order) && !self.limit_order_is_one_shot(),
694 };
695
696 if needs_new_order {
697 let result = if self.config.enable_brackets {
698 self.submit_bracket_order(OrderSide::Buy, price)
699 } else {
700 self.submit_limit_order(OrderSide::Buy, price)
701 };
702
703 if let Err(e) = result {
704 log::error!("Failed to submit buy order: {e}");
705 }
706 } else if let Some(order) = &self.buy_order
707 && order.venue_order_id().is_some()
708 && !order.is_pending_update()
709 && !order.is_pending_cancel()
710 {
711 let client_id = self.config.client_id;
712
713 if self.config.test_modify_rejected && !self.modify_rejected_attempted {
716 self.modify_rejected_attempted = true;
717 let order_clone = order.clone();
718 let bumped = clamp_price_to_range(
719 add_price_ticks(price, increment, 1, precision),
720 instrument,
721 self.config.clamp_to_instrument_price_range,
722 );
723
724 if let Err(e) = self.modify_order(
725 order_clone.client_order_id(),
726 None,
727 Some(bumped),
728 None,
729 client_id,
730 None,
731 ) {
732 log::error!("Failed to submit test modify on buy order: {e}");
733 }
734 return;
735 }
736
737 if let Some(order_price) = order.price()
738 && order_price < price
739 {
740 if self.config.modify_orders_to_maintain_tob_offset {
741 let order_clone = order.clone();
742 if let Err(e) = self.modify_order(
743 order_clone.client_order_id(),
744 None,
745 Some(price),
746 None,
747 client_id,
748 None,
749 ) {
750 log::error!("Failed to modify buy order: {e}");
751 }
752 } else if self.config.cancel_replace_orders_to_maintain_tob_offset {
753 let client_order_id = order.client_order_id();
754 self.start_limit_order_cancel_replace(OrderSide::Buy, client_order_id, price);
755 }
756 }
757 }
758 }
759
760 fn maintain_sell_orders(&mut self, best_bid: Price, best_ask: Price) {
762 self.refresh_tracked_order(OrderSide::Sell);
765
766 let Some(instrument) = &self.instrument else {
767 return;
768 };
769
770 let Some(price) = self.limit_price(OrderSide::Sell, best_bid, best_ask) else {
771 return;
772 };
773
774 let increment = instrument.price_increment();
775 let precision = instrument.price_precision();
776
777 if self.limit_order_maintenance_suppressed(OrderSide::Sell) {
778 return;
779 }
780
781 let needs_new_order = match &self.sell_order {
782 None => true,
783 Some(order) => !Self::is_order_active(order) && !self.limit_order_is_one_shot(),
784 };
785
786 if needs_new_order {
787 let result = if self.config.enable_brackets {
788 self.submit_bracket_order(OrderSide::Sell, price)
789 } else {
790 self.submit_limit_order(OrderSide::Sell, price)
791 };
792
793 if let Err(e) = result {
794 log::error!("Failed to submit sell order: {e}");
795 }
796 } else if let Some(order) = &self.sell_order
797 && order.venue_order_id().is_some()
798 && !order.is_pending_update()
799 && !order.is_pending_cancel()
800 {
801 let client_id = self.config.client_id;
802
803 if self.config.test_modify_rejected && !self.modify_rejected_attempted {
805 self.modify_rejected_attempted = true;
806 let order_clone = order.clone();
807 let bumped = clamp_price_to_range(
808 sub_price_ticks(price, increment, 1, precision),
809 instrument,
810 self.config.clamp_to_instrument_price_range,
811 );
812
813 if let Err(e) = self.modify_order(
814 order_clone.client_order_id(),
815 None,
816 Some(bumped),
817 None,
818 client_id,
819 None,
820 ) {
821 log::error!("Failed to submit test modify on sell order: {e}");
822 }
823 return;
824 }
825
826 if let Some(order_price) = order.price()
827 && order_price > price
828 {
829 if self.config.modify_orders_to_maintain_tob_offset {
830 let order_clone = order.clone();
831 if let Err(e) = self.modify_order(
832 order_clone.client_order_id(),
833 None,
834 Some(price),
835 None,
836 client_id,
837 None,
838 ) {
839 log::error!("Failed to modify sell order: {e}");
840 }
841 } else if self.config.cancel_replace_orders_to_maintain_tob_offset {
842 let client_order_id = order.client_order_id();
843 self.start_limit_order_cancel_replace(OrderSide::Sell, client_order_id, price);
844 }
845 }
846 }
847 }
848
849 fn handle_limit_order_accepted(&mut self, client_order_id: ClientOrderId) {
850 let Some(side) = self.limit_order_side_for_state(client_order_id) else {
851 return;
852 };
853
854 match self.limit_order_maintenance_state(side) {
855 LimitOrderMaintenanceState::AwaitingAcceptance { .. } => {
856 self.refresh_tracked_order(side);
857 if self.config.trigger_limit_order_maintenance_once {
858 self.trigger_limit_order_maintenance(side, client_order_id);
859 } else {
860 self.set_limit_order_maintenance_state(
861 side,
862 LimitOrderMaintenanceState::Active { client_order_id },
863 );
864 }
865 }
866 LimitOrderMaintenanceState::AwaitingReplacementAcceptance { price, .. } => {
867 self.refresh_tracked_order(side);
868 let accepted_at_expected_price = self
869 .tracked_limit_order(side)
870 .is_some_and(|order| order.price() == Some(price) && order.is_open());
871 if !accepted_at_expected_price {
872 log::error!(
873 "Replacement {side} order {client_order_id} was accepted with unexpected state"
874 );
875 self.set_limit_order_maintenance_state(
876 side,
877 LimitOrderMaintenanceState::Failed,
878 );
879 return;
880 }
881 self.set_limit_order_maintenance_state(side, LimitOrderMaintenanceState::Completed);
882 }
883 _ => {}
884 }
885 }
886
887 fn trigger_limit_order_maintenance(&mut self, side: OrderSide, client_order_id: ClientOrderId) {
888 let Some(order_price) = self.tracked_limit_order(side).and_then(Order::price) else {
889 log::error!("Accepted {side} limit order {client_order_id} has no price");
890 self.set_limit_order_maintenance_state(side, LimitOrderMaintenanceState::Failed);
891 return;
892 };
893 let Some(price) = self.limit_order_trigger_price(side, order_price) else {
894 log::error!(
895 "Cannot find a different valid price for accepted {side} limit order {client_order_id}"
896 );
897 self.set_limit_order_maintenance_state(side, LimitOrderMaintenanceState::Failed);
898 return;
899 };
900
901 if self.config.modify_orders_to_maintain_tob_offset {
902 self.set_limit_order_maintenance_state(
903 side,
904 LimitOrderMaintenanceState::AwaitingUpdate {
905 client_order_id,
906 price,
907 },
908 );
909
910 if let Err(e) = self.modify_order(
911 client_order_id,
912 None,
913 Some(price),
914 None,
915 self.config.client_id,
916 None,
917 ) {
918 self.set_limit_order_maintenance_state(side, LimitOrderMaintenanceState::Failed);
919 log::error!("Failed to submit one-shot {side} limit order modify: {e}");
920 }
921 } else if self.config.cancel_replace_orders_to_maintain_tob_offset {
922 self.start_limit_order_cancel_replace(side, client_order_id, price);
923 } else {
924 self.set_limit_order_maintenance_state(side, LimitOrderMaintenanceState::Failed);
925 log::error!("No limit order maintenance mode configured for one-shot trigger");
926 }
927 }
928
929 fn start_limit_order_cancel_replace(
930 &mut self,
931 side: OrderSide,
932 client_order_id: ClientOrderId,
933 replacement_price: Price,
934 ) {
935 let state = self.limit_order_maintenance_state(side);
936 if !matches!(
937 state,
938 LimitOrderMaintenanceState::AwaitingAcceptance {
939 client_order_id: expected,
940 } | LimitOrderMaintenanceState::Active {
941 client_order_id: expected,
942 } if expected == client_order_id
943 ) {
944 return;
945 }
946
947 self.set_limit_order_maintenance_state(
948 side,
949 LimitOrderMaintenanceState::AwaitingCancel {
950 client_order_id,
951 replacement_price,
952 },
953 );
954
955 if let Err(e) = self.cancel_order(client_order_id, self.config.client_id, None) {
956 self.set_limit_order_maintenance_state(side, LimitOrderMaintenanceState::Failed);
957 log::error!("Failed to cancel {side} limit order for replacement: {e}");
958 }
959 }
960
961 fn handle_limit_order_updated(
962 &mut self,
963 client_order_id: ClientOrderId,
964 updated_price: Option<Price>,
965 ) {
966 let Some(side) = self.limit_order_side_for_state(client_order_id) else {
967 return;
968 };
969 let LimitOrderMaintenanceState::AwaitingUpdate { price, .. } =
970 self.limit_order_maintenance_state(side)
971 else {
972 return;
973 };
974
975 self.refresh_tracked_order(side);
976 let updated_at_expected_price = updated_price == Some(price)
977 && self
978 .tracked_limit_order(side)
979 .is_some_and(|order| order.price() == Some(price) && order.is_open());
980 if !updated_at_expected_price {
981 log::error!(
982 "Updated {side} limit order {client_order_id} has unexpected price or state"
983 );
984 self.set_limit_order_maintenance_state(side, LimitOrderMaintenanceState::Failed);
985 return;
986 }
987 self.set_limit_order_maintenance_state(side, LimitOrderMaintenanceState::Completed);
988 }
989
990 fn handle_limit_order_canceled(&mut self, client_order_id: ClientOrderId) {
991 let Some(side) = self.limit_order_side_for_state(client_order_id) else {
992 return;
993 };
994 let LimitOrderMaintenanceState::AwaitingCancel {
995 replacement_price, ..
996 } = self.limit_order_maintenance_state(side)
997 else {
998 self.handle_limit_order_closed(client_order_id);
999 return;
1000 };
1001
1002 self.refresh_tracked_order(side);
1003 let Some(leaves_qty) = self
1004 .tracked_limit_order(side)
1005 .filter(|order| order.client_order_id() == client_order_id)
1006 .map(Order::leaves_qty)
1007 else {
1008 self.set_limit_order_maintenance_state(side, LimitOrderMaintenanceState::Failed);
1009 log::error!("Canceled {side} limit order {client_order_id} is not tracked");
1010 return;
1011 };
1012
1013 if leaves_qty.is_zero() {
1014 self.set_limit_order_maintenance_state(side, LimitOrderMaintenanceState::Failed);
1015 log::warn!(
1016 "Canceled {side} limit order {client_order_id} has no remaining quantity to replace"
1017 );
1018 return;
1019 }
1020
1021 if let Err(e) = self.submit_limit_order_replacement(side, replacement_price, leaves_qty) {
1022 self.set_limit_order_maintenance_state(side, LimitOrderMaintenanceState::Failed);
1023 log::error!("Failed to submit replacement {side} limit order: {e}");
1024 }
1025 }
1026
1027 fn finish_limit_order_maintenance(&mut self, client_order_id: ClientOrderId) {
1028 let Some(side) = self.limit_order_side_for_state(client_order_id) else {
1029 return;
1030 };
1031
1032 if matches!(
1033 self.limit_order_maintenance_state(side),
1034 LimitOrderMaintenanceState::AwaitingUpdate { .. }
1035 | LimitOrderMaintenanceState::AwaitingCancel { .. }
1036 | LimitOrderMaintenanceState::AwaitingReplacementAcceptance { .. }
1037 ) {
1038 self.set_limit_order_maintenance_state(side, LimitOrderMaintenanceState::Failed);
1039 }
1040 }
1041
1042 fn handle_limit_order_closed(&mut self, client_order_id: ClientOrderId) {
1043 let Some(side) = self.limit_order_side_for_state(client_order_id) else {
1044 return;
1045 };
1046 self.refresh_tracked_order(side);
1047 let state = match self.limit_order_maintenance_state(side) {
1048 LimitOrderMaintenanceState::AwaitingAcceptance { .. }
1049 | LimitOrderMaintenanceState::Active { .. } => LimitOrderMaintenanceState::Ready,
1050 LimitOrderMaintenanceState::AwaitingUpdate { .. }
1051 | LimitOrderMaintenanceState::AwaitingCancel { .. }
1052 | LimitOrderMaintenanceState::AwaitingReplacementAcceptance { .. } => {
1053 LimitOrderMaintenanceState::Failed
1054 }
1055 state => state,
1056 };
1057 self.set_limit_order_maintenance_state(side, state);
1058 }
1059
1060 fn limit_order_trigger_price(&self, side: OrderSide, order_price: Price) -> Option<Price> {
1061 let instrument = self.instrument.as_ref()?;
1062 let increment = instrument.price_increment();
1063 let precision = instrument.price_precision();
1064 let passive = match side {
1065 OrderSide::Buy => sub_price_ticks(order_price, increment, 1, precision),
1066 OrderSide::Sell => add_price_ticks(order_price, increment, 1, precision),
1067 };
1068 let passive = clamp_price_to_range(passive, instrument, true);
1069 if passive != order_price {
1070 return Some(passive);
1071 }
1072
1073 let aggressive = match side {
1074 OrderSide::Buy => add_price_ticks(order_price, increment, 1, precision),
1075 OrderSide::Sell => sub_price_ticks(order_price, increment, 1, precision),
1076 };
1077 let aggressive = clamp_price_to_range(aggressive, instrument, true);
1078 (aggressive != order_price).then_some(aggressive)
1079 }
1080
1081 fn limit_order_maintenance_suppressed(&self, side: OrderSide) -> bool {
1082 let state = self.limit_order_maintenance_state(side);
1083 matches!(
1084 state,
1085 LimitOrderMaintenanceState::AwaitingUpdate { .. }
1086 | LimitOrderMaintenanceState::AwaitingCancel { .. }
1087 | LimitOrderMaintenanceState::AwaitingReplacementAcceptance { .. }
1088 ) || (self.config.trigger_limit_order_maintenance_once
1089 && matches!(
1090 state,
1091 LimitOrderMaintenanceState::Completed | LimitOrderMaintenanceState::Failed
1092 ))
1093 }
1094
1095 fn limit_order_side_for_state(&self, client_order_id: ClientOrderId) -> Option<OrderSide> {
1096 [OrderSide::Buy, OrderSide::Sell].into_iter().find(|side| {
1097 self.limit_order_maintenance_state(*side).client_order_id() == Some(client_order_id)
1098 })
1099 }
1100
1101 const fn limit_order_maintenance_state(&self, side: OrderSide) -> LimitOrderMaintenanceState {
1102 match side {
1103 OrderSide::Buy => self.buy_limit_maintenance_state,
1104 OrderSide::Sell => self.sell_limit_maintenance_state,
1105 }
1106 }
1107
1108 fn set_limit_order_maintenance_state(
1109 &mut self,
1110 side: OrderSide,
1111 state: LimitOrderMaintenanceState,
1112 ) {
1113 match side {
1114 OrderSide::Buy => self.buy_limit_maintenance_state = state,
1115 OrderSide::Sell => self.sell_limit_maintenance_state = state,
1116 }
1117 }
1118
1119 fn tracked_limit_order(&self, side: OrderSide) -> Option<&OrderAny> {
1120 match side {
1121 OrderSide::Buy => self.buy_order.as_ref(),
1122 OrderSide::Sell => self.sell_order.as_ref(),
1123 }
1124 }
1125
1126 fn maintain_batch_limit_pair(&mut self, best_bid: Price, best_ask: Price) {
1128 self.refresh_tracked_order(OrderSide::Buy);
1132 self.refresh_tracked_order(OrderSide::Sell);
1133
1134 let Some(instrument) = &self.instrument else {
1135 return;
1136 };
1137
1138 let buy_needs = match &self.buy_order {
1139 None => true,
1140 Some(order) => !Self::is_order_active(order) && !self.limit_order_is_one_shot(),
1141 };
1142 let sell_needs = match &self.sell_order {
1143 None => true,
1144 Some(order) => !Self::is_order_active(order) && !self.limit_order_is_one_shot(),
1145 };
1146
1147 if !buy_needs || !sell_needs {
1148 return;
1149 }
1150
1151 let Some(buy_price) = self.limit_price(OrderSide::Buy, best_bid, best_ask) else {
1152 return;
1153 };
1154
1155 let Some(sell_price) = self.limit_price(OrderSide::Sell, best_bid, best_ask) else {
1156 return;
1157 };
1158
1159 let quantity = instrument.make_qty_from_decimal(self.config.order_qty.as_decimal(), None);
1160 let (time_in_force, expire_time) =
1161 self.resolve_time_in_force(self.config.limit_time_in_force);
1162 let instrument_id = self.config.instrument_id;
1163 let post_only = self.config.use_post_only || self.config.test_reject_post_only;
1164 let quote_quantity = self.config.use_quote_quantity;
1165 let display_qty = self.config.order_display_qty;
1166 let emulation_trigger = self.config.emulation_trigger;
1167
1168 let buy_order = self.order_factory().limit(
1169 instrument_id,
1170 OrderSide::Buy,
1171 quantity,
1172 buy_price,
1173 Some(time_in_force),
1174 expire_time,
1175 Some(post_only),
1176 None,
1177 Some(quote_quantity),
1178 display_qty,
1179 emulation_trigger,
1180 None,
1181 None,
1182 None,
1183 None,
1184 None,
1185 );
1186
1187 let sell_order = self.order_factory().limit(
1188 instrument_id,
1189 OrderSide::Sell,
1190 quantity,
1191 sell_price,
1192 Some(time_in_force),
1193 expire_time,
1194 Some(post_only),
1195 None,
1196 Some(quote_quantity),
1197 display_qty,
1198 emulation_trigger,
1199 None,
1200 None,
1201 None,
1202 None,
1203 None,
1204 );
1205
1206 self.buy_order = Some(buy_order.clone());
1207 self.sell_order = Some(sell_order.clone());
1208
1209 let client_id = self.config.client_id;
1210 let params = self.config.order_params.clone();
1211 if let Err(e) = self.submit_order_list(vec![buy_order, sell_order], None, client_id, params)
1212 {
1213 log::error!("Failed to submit batch limit pair: {e}");
1214 }
1215 }
1216
1217 fn limit_price(&self, side: OrderSide, best_bid: Price, best_ask: Price) -> Option<Price> {
1218 let instrument = self.instrument.as_ref()?;
1219 let offset_ticks = self.price_offset?;
1220 let increment = instrument.price_increment();
1221 let precision = instrument.price_precision();
1222 let cross_spread = self.config.test_reject_post_only || self.config.limit_aggressive;
1223
1224 let price = match (side, cross_spread) {
1225 (OrderSide::Buy, false) | (OrderSide::Sell, true) => {
1226 sub_price_ticks(best_bid, increment, offset_ticks, precision)
1227 }
1228 (OrderSide::Buy, true) | (OrderSide::Sell, false) => {
1229 add_price_ticks(best_ask, increment, offset_ticks, precision)
1230 }
1231 };
1232
1233 let price = clamp_price_to_range(
1234 price,
1235 instrument,
1236 self.config.clamp_to_instrument_price_range,
1237 );
1238
1239 if !price.is_positive() {
1240 log_warn!("Skipping {side} limit order with non-positive price {price}");
1241 return None;
1242 }
1243
1244 Some(price)
1245 }
1246
1247 fn maintain_stop_buy_orders(&mut self, best_bid: Price, best_ask: Price) {
1249 self.refresh_tracked_stop_order(OrderSide::Buy);
1250
1251 if let Some(order) = self.buy_stop_order.as_ref()
1253 && matches!(order.status(), OrderStatus::Rejected | OrderStatus::Denied)
1254 {
1255 return;
1256 }
1257
1258 let Some(instrument) = &self.instrument else {
1259 return;
1260 };
1261
1262 let increment = instrument.price_increment();
1263 let precision = instrument.price_precision();
1264 let stop_offset_ticks = self.config.stop_offset_ticks;
1265
1266 let unclamped_trigger_price = if matches!(
1268 self.config.stop_order_type,
1269 OrderType::LimitIfTouched | OrderType::MarketIfTouched | OrderType::TrailingStopMarket
1270 ) {
1271 sub_price_ticks(best_bid, increment, stop_offset_ticks, precision)
1273 } else {
1274 add_price_ticks(best_ask, increment, stop_offset_ticks, precision)
1276 };
1277 let clamp = self.config.clamp_to_instrument_price_range;
1278 let trigger_price = clamp_price_to_range(unclamped_trigger_price, instrument, clamp);
1279
1280 let limit_price = if matches!(
1282 self.config.stop_order_type,
1283 OrderType::StopLimit | OrderType::LimitIfTouched
1284 ) {
1285 let unclamped_limit_price =
1286 if let Some(limit_offset_ticks) = self.config.stop_limit_offset_ticks {
1287 add_price_ticks(trigger_price, increment, limit_offset_ticks, precision)
1289 } else {
1290 trigger_price
1291 };
1292 Some(clamp_price_to_range(
1293 unclamped_limit_price,
1294 instrument,
1295 clamp,
1296 ))
1297 } else {
1298 None
1299 };
1300
1301 if let Some(replacement) = &mut self.buy_stop_replacement {
1302 replacement.trigger_price = trigger_price;
1303 replacement.limit_price = limit_price;
1304 return;
1305 }
1306
1307 let needs_new_order = match &self.buy_stop_order {
1308 None => true,
1309 Some(order) => !Self::is_order_active(order) && !self.stop_order_is_one_shot(),
1310 };
1311
1312 if needs_new_order {
1313 if let Err(e) = self.submit_stop_order(OrderSide::Buy, trigger_price, limit_price) {
1314 log::error!("Failed to submit buy stop order: {e}");
1315 }
1316 } else if let Some(order) = &self.buy_stop_order
1317 && order.venue_order_id().is_some()
1318 && !order.is_pending_update()
1319 && !order.is_pending_cancel()
1320 {
1321 let current_trigger = Self::get_order_trigger_price(order);
1322 if current_trigger.is_some() && current_trigger != Some(trigger_price) {
1323 if self.config.modify_stop_orders_to_maintain_offset {
1324 let order_clone = order.clone();
1325 if let Err(e) = self.modify_stop_order(&order_clone, trigger_price, limit_price)
1326 {
1327 log::error!("Failed to modify buy stop order: {e}");
1328 }
1329 } else if self.config.cancel_replace_stop_orders_to_maintain_offset
1330 && !self.buy_stop_cancel_replace_attempted
1331 {
1332 let client_order_id = order.client_order_id();
1333 self.start_stop_order_cancel_replace(
1334 OrderSide::Buy,
1335 client_order_id,
1336 trigger_price,
1337 limit_price,
1338 );
1339 }
1340 }
1341 }
1342 }
1343
1344 fn maintain_stop_sell_orders(&mut self, best_bid: Price, best_ask: Price) {
1346 self.refresh_tracked_stop_order(OrderSide::Sell);
1347
1348 if let Some(order) = self.sell_stop_order.as_ref()
1350 && matches!(order.status(), OrderStatus::Rejected | OrderStatus::Denied)
1351 {
1352 return;
1353 }
1354
1355 let Some(instrument) = &self.instrument else {
1356 return;
1357 };
1358
1359 let increment = instrument.price_increment();
1360 let precision = instrument.price_precision();
1361 let stop_offset_ticks = self.config.stop_offset_ticks;
1362
1363 let unclamped_trigger_price = if matches!(
1365 self.config.stop_order_type,
1366 OrderType::LimitIfTouched | OrderType::MarketIfTouched | OrderType::TrailingStopMarket
1367 ) {
1368 add_price_ticks(best_ask, increment, stop_offset_ticks, precision)
1370 } else {
1371 sub_price_ticks(best_bid, increment, stop_offset_ticks, precision)
1373 };
1374 let clamp = self.config.clamp_to_instrument_price_range;
1375 let trigger_price = clamp_price_to_range(unclamped_trigger_price, instrument, clamp);
1376
1377 let limit_price = if matches!(
1379 self.config.stop_order_type,
1380 OrderType::StopLimit | OrderType::LimitIfTouched
1381 ) {
1382 let unclamped_limit_price =
1383 if let Some(limit_offset_ticks) = self.config.stop_limit_offset_ticks {
1384 sub_price_ticks(trigger_price, increment, limit_offset_ticks, precision)
1386 } else {
1387 trigger_price
1388 };
1389 Some(clamp_price_to_range(
1390 unclamped_limit_price,
1391 instrument,
1392 clamp,
1393 ))
1394 } else {
1395 None
1396 };
1397
1398 if let Some(replacement) = &mut self.sell_stop_replacement {
1399 replacement.trigger_price = trigger_price;
1400 replacement.limit_price = limit_price;
1401 return;
1402 }
1403
1404 let needs_new_order = match &self.sell_stop_order {
1405 None => true,
1406 Some(order) => !Self::is_order_active(order) && !self.stop_order_is_one_shot(),
1407 };
1408
1409 if needs_new_order {
1410 if let Err(e) = self.submit_stop_order(OrderSide::Sell, trigger_price, limit_price) {
1411 log::error!("Failed to submit sell stop order: {e}");
1412 }
1413 } else if let Some(order) = &self.sell_stop_order
1414 && order.venue_order_id().is_some()
1415 && !order.is_pending_update()
1416 && !order.is_pending_cancel()
1417 {
1418 let current_trigger = Self::get_order_trigger_price(order);
1419 if current_trigger.is_some() && current_trigger != Some(trigger_price) {
1420 if self.config.modify_stop_orders_to_maintain_offset {
1421 let order_clone = order.clone();
1422 if let Err(e) = self.modify_stop_order(&order_clone, trigger_price, limit_price)
1423 {
1424 log::error!("Failed to modify sell stop order: {e}");
1425 }
1426 } else if self.config.cancel_replace_stop_orders_to_maintain_offset
1427 && !self.sell_stop_cancel_replace_attempted
1428 {
1429 let client_order_id = order.client_order_id();
1430 self.start_stop_order_cancel_replace(
1431 OrderSide::Sell,
1432 client_order_id,
1433 trigger_price,
1434 limit_price,
1435 );
1436 }
1437 }
1438 }
1439 }
1440
1441 fn start_stop_order_cancel_replace(
1442 &mut self,
1443 side: OrderSide,
1444 client_order_id: ClientOrderId,
1445 trigger_price: Price,
1446 limit_price: Option<Price>,
1447 ) {
1448 let replacement = Some(StopOrderReplacement {
1449 client_order_id,
1450 trigger_price,
1451 limit_price,
1452 });
1453
1454 match side {
1455 OrderSide::Buy => {
1456 self.buy_stop_cancel_replace_attempted = true;
1457 self.buy_stop_replacement = replacement;
1458 }
1459 OrderSide::Sell => {
1460 self.sell_stop_cancel_replace_attempted = true;
1461 self.sell_stop_replacement = replacement;
1462 }
1463 }
1464
1465 if let Err(e) = self.cancel_order(client_order_id, self.config.client_id, None) {
1466 self.clear_stop_order_replacement(client_order_id);
1467 log::error!("Failed to cancel {side} stop order for replacement: {e}");
1468 }
1469 }
1470
1471 fn handle_stop_order_canceled(&mut self, event: &OrderCanceled) {
1472 let client_order_id = event.client_order_id;
1473
1474 let replacement = [
1475 (OrderSide::Buy, &mut self.buy_stop_replacement),
1476 (OrderSide::Sell, &mut self.sell_stop_replacement),
1477 ]
1478 .into_iter()
1479 .find_map(|(side, pending)| {
1480 if pending
1481 .as_ref()
1482 .is_some_and(|replacement| replacement.client_order_id == client_order_id)
1483 {
1484 if event.reconciliation {
1485 log::error!(
1486 "Cannot complete {side} stop cancel-replace from a reconciliation event for {client_order_id}, replacement remains pending"
1487 );
1488 return None;
1489 }
1490
1491 pending.take().map(|replacement| (side, replacement))
1492 } else {
1493 None
1494 }
1495 });
1496
1497 let Some((side, replacement)) = replacement else {
1498 return;
1499 };
1500
1501 let Some((quantity, quote_quantity)) = self
1502 .cache()
1503 .order(&client_order_id)
1504 .map(|order| (order.leaves_qty(), order.is_quote_quantity()))
1505 else {
1506 log::error!("Canceled {side} stop order {client_order_id} is not cached");
1507 return;
1508 };
1509
1510 if quantity.is_zero() {
1511 return;
1512 }
1513
1514 if let Err(e) = self.submit_stop_order_with_qty(
1515 side,
1516 quantity,
1517 replacement.trigger_price,
1518 replacement.limit_price,
1519 quote_quantity,
1520 ) {
1521 log::error!("Failed to submit replacement {side} stop order: {e}");
1522 }
1523 }
1524
1525 fn clear_stop_order_replacement(&mut self, client_order_id: ClientOrderId) {
1526 for pending in [
1527 &mut self.buy_stop_replacement,
1528 &mut self.sell_stop_replacement,
1529 ] {
1530 if pending
1531 .as_ref()
1532 .is_some_and(|replacement| replacement.client_order_id == client_order_id)
1533 {
1534 *pending = None;
1535 }
1536 }
1537 }
1538
1539 pub(super) fn submit_limit_order(
1545 &mut self,
1546 order_side: OrderSide,
1547 price: Price,
1548 ) -> anyhow::Result<()> {
1549 let Some(instrument) = self.instrument.as_ref() else {
1550 anyhow::bail!("No instrument loaded");
1551 };
1552
1553 let quantity = instrument.make_qty_from_decimal(self.config.order_qty.as_decimal(), None);
1554
1555 let Some(order) = self.create_tracked_limit_order(order_side, price, quantity)? else {
1556 return Ok(());
1557 };
1558 let client_order_id = order.client_order_id();
1559 self.arm_limit_order_maintenance(order_side, client_order_id);
1560
1561 if let Err(e) = self.submit_order_apply_params(order) {
1562 self.handle_limit_order_closed(client_order_id);
1563 return Err(e);
1564 }
1565 Ok(())
1566 }
1567
1568 fn submit_limit_order_replacement(
1569 &mut self,
1570 order_side: OrderSide,
1571 price: Price,
1572 quantity: Quantity,
1573 ) -> anyhow::Result<()> {
1574 let Some(order) = self.create_tracked_limit_order(order_side, price, quantity)? else {
1575 anyhow::bail!("Replacement {order_side} limit order was not created");
1576 };
1577 let client_order_id = order.client_order_id();
1578 self.set_limit_order_maintenance_state(
1579 order_side,
1580 LimitOrderMaintenanceState::AwaitingReplacementAcceptance {
1581 client_order_id,
1582 price,
1583 },
1584 );
1585 self.submit_order_apply_params(order)
1586 }
1587
1588 fn create_tracked_limit_order(
1589 &mut self,
1590 order_side: OrderSide,
1591 price: Price,
1592 quantity: Quantity,
1593 ) -> anyhow::Result<Option<OrderAny>> {
1594 if self.instrument.is_none() {
1595 anyhow::bail!("No instrument loaded");
1596 }
1597
1598 if self.config.dry_run {
1599 log_warn!("Dry run, skipping create {order_side:?} order");
1600 return Ok(None);
1601 }
1602
1603 if order_side == OrderSide::Buy && !self.config.enable_limit_buys {
1604 log_warn!("BUY orders not enabled, skipping");
1605 return Ok(None);
1606 } else if order_side == OrderSide::Sell && !self.config.enable_limit_sells {
1607 log_warn!("SELL orders not enabled, skipping");
1608 return Ok(None);
1609 }
1610
1611 let (time_in_force, expire_time) =
1612 self.resolve_time_in_force(self.config.limit_time_in_force);
1613
1614 let instrument_id = self.config.instrument_id;
1615 let post_only = self.config.use_post_only || self.config.test_reject_post_only;
1616 let quote_quantity = self.config.use_quote_quantity;
1617 let display_qty = self
1618 .config
1619 .order_display_qty
1620 .map(|display_qty| display_qty.min(quantity));
1621 let emulation_trigger = self.config.emulation_trigger;
1622
1623 let order = self.order_factory().limit(
1624 instrument_id,
1625 order_side,
1626 quantity,
1627 price,
1628 Some(time_in_force),
1629 expire_time,
1630 Some(post_only),
1631 None, Some(quote_quantity),
1633 display_qty,
1634 emulation_trigger,
1635 None, None, None, None, None, );
1641
1642 if order_side == OrderSide::Buy {
1643 self.buy_order = Some(order.clone());
1644 } else {
1645 self.sell_order = Some(order.clone());
1646 }
1647
1648 Ok(Some(order))
1649 }
1650
1651 fn arm_limit_order_maintenance(&mut self, side: OrderSide, client_order_id: ClientOrderId) {
1652 if matches!(
1653 self.limit_order_maintenance_state(side),
1654 LimitOrderMaintenanceState::Ready
1655 | LimitOrderMaintenanceState::AwaitingAcceptance { .. }
1656 | LimitOrderMaintenanceState::Active { .. }
1657 ) {
1658 self.set_limit_order_maintenance_state(
1659 side,
1660 LimitOrderMaintenanceState::AwaitingAcceptance { client_order_id },
1661 );
1662 }
1663 }
1664
1665 pub(super) fn submit_stop_order(
1671 &mut self,
1672 order_side: OrderSide,
1673 trigger_price: Price,
1674 limit_price: Option<Price>,
1675 ) -> anyhow::Result<()> {
1676 let Some(instrument) = &self.instrument else {
1677 anyhow::bail!("No instrument loaded");
1678 };
1679
1680 if self.config.dry_run {
1681 log_warn!("Dry run, skipping create {order_side:?} stop order");
1682 return Ok(());
1683 }
1684
1685 if order_side == OrderSide::Buy && !self.config.enable_stop_buys {
1686 log_warn!("BUY stop orders not enabled, skipping");
1687 return Ok(());
1688 } else if order_side == OrderSide::Sell && !self.config.enable_stop_sells {
1689 log_warn!("SELL stop orders not enabled, skipping");
1690 return Ok(());
1691 }
1692
1693 let quantity = instrument.make_qty_from_decimal(self.config.order_qty.as_decimal(), None);
1694
1695 self.submit_stop_order_with_qty(
1696 order_side,
1697 quantity,
1698 trigger_price,
1699 limit_price,
1700 self.config.use_quote_quantity,
1701 )
1702 }
1703
1704 #[expect(
1705 clippy::too_many_lines,
1706 reason = "stop order submission covers all supported stop order scenarios"
1707 )]
1708 fn submit_stop_order_with_qty(
1709 &mut self,
1710 order_side: OrderSide,
1711 quantity: Quantity,
1712 trigger_price: Price,
1713 limit_price: Option<Price>,
1714 quote_quantity: bool,
1715 ) -> anyhow::Result<()> {
1716 let (time_in_force, expire_time) =
1717 self.resolve_time_in_force(self.config.stop_time_in_force);
1718
1719 let instrument_id = self.config.instrument_id;
1720 let trigger_type = self.config.stop_trigger_type;
1721 let display_qty = self
1722 .config
1723 .order_display_qty
1724 .map(|display_qty| display_qty.min(quantity));
1725 let emulation_trigger = self.config.emulation_trigger;
1726 let stop_order_type = self.config.stop_order_type;
1727 let trailing_offset = self.config.trailing_offset;
1728 let trailing_offset_type = self.config.trailing_offset_type;
1729
1730 let mut factory = self.order_factory();
1731
1732 let mut order: OrderAny = match stop_order_type {
1733 OrderType::StopMarket => factory.stop_market(
1734 instrument_id,
1735 order_side,
1736 quantity,
1737 trigger_price,
1738 Some(trigger_type),
1739 Some(time_in_force),
1740 expire_time,
1741 None, Some(quote_quantity),
1743 None, emulation_trigger,
1745 None, None, None, None, None, ),
1751 OrderType::StopLimit => {
1752 let Some(limit_price) = limit_price else {
1753 anyhow::bail!("STOP_LIMIT order requires limit_price");
1754 };
1755 factory.stop_limit(
1756 instrument_id,
1757 order_side,
1758 quantity,
1759 limit_price,
1760 trigger_price,
1761 Some(trigger_type),
1762 Some(time_in_force),
1763 expire_time,
1764 None, None, Some(quote_quantity),
1767 display_qty,
1768 emulation_trigger,
1769 None, None, None, None, None, )
1775 }
1776 OrderType::MarketIfTouched => factory.market_if_touched(
1777 instrument_id,
1778 order_side,
1779 quantity,
1780 trigger_price,
1781 Some(trigger_type),
1782 Some(time_in_force),
1783 expire_time,
1784 None, Some(quote_quantity),
1786 emulation_trigger,
1787 None, None, None, None, None, ),
1793 OrderType::LimitIfTouched => {
1794 let Some(limit_price) = limit_price else {
1795 anyhow::bail!("LIMIT_IF_TOUCHED order requires limit_price");
1796 };
1797 factory.limit_if_touched(
1798 instrument_id,
1799 order_side,
1800 quantity,
1801 limit_price,
1802 trigger_price,
1803 Some(trigger_type),
1804 Some(time_in_force),
1805 expire_time,
1806 None, None, Some(quote_quantity),
1809 display_qty,
1810 emulation_trigger,
1811 None, None, None, None, None, )
1817 }
1818 OrderType::TrailingStopMarket => {
1819 let Some(trailing_offset) = trailing_offset else {
1820 anyhow::bail!("TRAILING_STOP_MARKET order requires trailing_offset config");
1821 };
1822 factory.trailing_stop_market(
1823 instrument_id,
1824 order_side,
1825 quantity,
1826 trailing_offset,
1827 Some(trailing_offset_type),
1828 None,
1829 Some(trigger_price),
1830 Some(trigger_type),
1831 Some(time_in_force),
1832 expire_time,
1833 None, Some(quote_quantity),
1835 None, emulation_trigger,
1837 None, None, None, None, None, )
1843 }
1844 _ => {
1845 anyhow::bail!("Unknown stop order type: {stop_order_type:?}");
1846 }
1847 };
1848 drop(factory);
1849
1850 if let OrderAny::TrailingStopMarket(order) = &mut order {
1851 order.activation_price = Some(trigger_price);
1852 }
1853
1854 if order_side == OrderSide::Buy {
1855 self.buy_stop_order = Some(order.clone());
1856 } else {
1857 self.sell_stop_order = Some(order.clone());
1858 }
1859
1860 self.submit_order_apply_params(order)
1861 }
1862
1863 #[expect(
1869 clippy::too_many_lines,
1870 reason = "bracket validation and linked entry, stop-loss, and take-profit construction stay together"
1871 )]
1872 pub(super) fn submit_bracket_order(
1873 &mut self,
1874 order_side: OrderSide,
1875 entry_price: Price,
1876 ) -> anyhow::Result<()> {
1877 let Some(instrument) = &self.instrument else {
1878 anyhow::bail!("No instrument loaded");
1879 };
1880
1881 if self.config.dry_run {
1882 log_warn!("Dry run, skipping create {order_side:?} bracket order");
1883 return Ok(());
1884 }
1885
1886 if self.config.bracket_entry_order_type != OrderType::Limit {
1887 anyhow::bail!(
1888 "Only Limit entry orders are supported for brackets, was {:?}",
1889 self.config.bracket_entry_order_type
1890 );
1891 }
1892
1893 anyhow::ensure!(
1894 matches!(
1895 self.config.bracket_contingency_type,
1896 ContingencyType::Oco | ContingencyType::Ouo
1897 ),
1898 "Bracket exits require OCO or OUO contingency, was {:?}",
1899 self.config.bracket_contingency_type
1900 );
1901 anyhow::ensure!(
1902 matches!(
1903 self.config.bracket_tp_order_type,
1904 OrderType::Limit | OrderType::MarketIfTouched | OrderType::LimitIfTouched
1905 ),
1906 "Bracket take-profit requires LIMIT, MARKET_IF_TOUCHED, or LIMIT_IF_TOUCHED, was {:?}",
1907 self.config.bracket_tp_order_type
1908 );
1909
1910 if order_side == OrderSide::Buy && !self.config.enable_limit_buys {
1911 log_warn!("BUY orders not enabled, skipping bracket");
1912 return Ok(());
1913 } else if order_side == OrderSide::Sell && !self.config.enable_limit_sells {
1914 log_warn!("SELL orders not enabled, skipping bracket");
1915 return Ok(());
1916 }
1917
1918 if matches!(
1919 (
1920 self.config.limit_time_in_force,
1921 self.config.order_expire_time_delta_mins
1922 ),
1923 (Some(TimeInForce::Gtd), _) | (None, Some(_))
1924 ) {
1925 anyhow::bail!("GTD time in force not supported for bracket take-profit legs");
1926 }
1927
1928 let (time_in_force, expire_time) =
1929 self.resolve_time_in_force(self.config.limit_time_in_force);
1930 let sl_time_in_force = self.config.stop_time_in_force.unwrap_or(TimeInForce::Gtc);
1931 if sl_time_in_force == TimeInForce::Gtd {
1932 anyhow::bail!("GTD time in force not supported for bracket stop-loss legs");
1933 }
1934
1935 let quantity = instrument.make_qty_from_decimal(self.config.order_qty.as_decimal(), None);
1936 let increment = instrument.price_increment();
1937 let precision = instrument.price_precision();
1938 let bracket_offset_ticks = self.config.bracket_offset_ticks;
1939
1940 let (unclamped_tp_price, unclamped_sl_trigger_price) = match order_side {
1941 OrderSide::Buy => {
1942 let tp = add_price_ticks(entry_price, increment, bracket_offset_ticks, precision);
1943 let sl = sub_price_ticks(entry_price, increment, bracket_offset_ticks, precision);
1944 (tp, sl)
1945 }
1946 OrderSide::Sell => {
1947 let tp = sub_price_ticks(entry_price, increment, bracket_offset_ticks, precision);
1948 let sl = add_price_ticks(entry_price, increment, bracket_offset_ticks, precision);
1949 (tp, sl)
1950 }
1951 };
1952 let clamp = self.config.clamp_to_instrument_price_range;
1953 let tp_price = clamp_price_to_range(unclamped_tp_price, instrument, clamp);
1954 let sl_trigger_price = clamp_price_to_range(unclamped_sl_trigger_price, instrument, clamp);
1955
1956 let entry_post_only = self.config.use_post_only || self.config.test_reject_post_only;
1957 let instrument_id = self.config.instrument_id;
1958 let quote_quantity = self.config.use_quote_quantity;
1959 let emulation_trigger = self.config.emulation_trigger;
1960 let stop_trigger_type = self.config.stop_trigger_type;
1961 let contingency_type = self.config.bracket_contingency_type;
1962 let tp_order_type = self.config.bracket_tp_order_type;
1963 let orders = self
1964 .order_factory()
1965 .bracket()
1966 .instrument_id(instrument_id)
1967 .order_side(order_side)
1968 .quantity(quantity)
1969 .quote_quantity(quote_quantity)
1970 .contingency_type(contingency_type)
1971 .entry_order_type(OrderType::Limit)
1972 .entry_price(entry_price)
1973 .time_in_force(time_in_force)
1974 .entry_post_only(entry_post_only)
1975 .maybe_emulation_trigger(emulation_trigger)
1976 .maybe_expire_time(expire_time)
1977 .tp_order_type(tp_order_type)
1978 .tp_price(tp_price)
1979 .tp_trigger_price(tp_price)
1980 .tp_post_only(entry_post_only)
1981 .tp_time_in_force(time_in_force)
1982 .sl_trigger_price(sl_trigger_price)
1983 .sl_trigger_type(stop_trigger_type)
1984 .sl_time_in_force(sl_time_in_force)
1985 .call();
1986
1987 let entry_order = &orders[0];
1988 if order_side == OrderSide::Buy {
1989 self.buy_order = Some(entry_order.clone());
1990 } else {
1991 self.sell_order = Some(entry_order.clone());
1992 }
1993
1994 self.arm_limit_order_maintenance(order_side, entry_order.client_order_id());
1995
1996 let client_id = self.config.client_id;
1997 if let Some(params) = &self.config.order_params {
1998 self.submit_order_list(orders, None, client_id, Some(params.clone()))
1999 } else {
2000 self.submit_order_list(orders, None, client_id, None)
2001 }
2002 }
2003
2004 fn close_positions_on_stop(
2005 &mut self,
2006 strategy_id: StrategyId,
2007 time_in_force: Option<TimeInForce>,
2008 ) -> anyhow::Result<()> {
2009 let instrument_id = self.config.instrument_id;
2010 let client_id = self.config.client_id;
2011 let reduce_only = Some(self.config.reduce_only_on_stop);
2012 let Some(precision) = self.config.close_positions_qty_precision else {
2013 return self.close_all_positions(
2014 instrument_id,
2015 None,
2016 client_id,
2017 None,
2018 time_in_force,
2019 reduce_only,
2020 None,
2021 None,
2022 );
2023 };
2024
2025 let positions =
2026 self.cache()
2027 .positions_open(None, Some(&instrument_id), Some(&strategy_id), None, None);
2028
2029 if positions.is_empty() {
2030 log::info!("No {instrument_id} open positions to close");
2031 return Ok(());
2032 }
2033
2034 log::info!(
2035 "Closing {} open position{}",
2036 positions.len(),
2037 if positions.len() == 1 { "" } else { "s" },
2038 );
2039
2040 for position in positions {
2041 let position_id = position.id;
2042 let (close_quantity, residual) = split_position_quantity(position.quantity, precision)?;
2043
2044 if close_quantity.is_zero() {
2045 log_warn!(
2046 "Position {position_id} has no venue-fillable close quantity at {precision}-decimal precision; exact residual remains {residual}"
2047 );
2048 continue;
2049 }
2050
2051 if residual > Decimal::ZERO {
2052 log_warn!(
2053 "Position {position_id} close quantity {close_quantity} leaves exact residual {residual} after a full fill"
2054 );
2055 }
2056
2057 let Some(closing_side) = OrderCore::closing_side(position.side) else {
2058 continue;
2059 };
2060 let order = self.order_factory().market(
2061 position.instrument_id,
2062 closing_side,
2063 close_quantity,
2064 time_in_force,
2065 reduce_only,
2066 None,
2067 None,
2068 None,
2069 None,
2070 None,
2071 );
2072
2073 self.submit_order(order, Some(position_id), client_id, None)?;
2074 }
2075
2076 Ok(())
2077 }
2078
2079 pub(super) fn open_position(&mut self, net_qty: Decimal) -> anyhow::Result<()> {
2085 let Some(instrument) = &self.instrument else {
2086 anyhow::bail!("No instrument loaded");
2087 };
2088
2089 if self.config.dry_run {
2090 log_warn!("Dry run, skipping open position");
2091 return Ok(());
2092 }
2093
2094 if net_qty == Decimal::ZERO {
2095 log_warn!("Open position with zero quantity, skipping");
2096 return Ok(());
2097 }
2098
2099 let order_side = if net_qty > Decimal::ZERO {
2100 OrderSide::Buy
2101 } else {
2102 OrderSide::Sell
2103 };
2104
2105 let quantity = instrument.make_qty_from_decimal(net_qty.abs(), None);
2106
2107 let reduce_only = if self.config.test_reject_reduce_only {
2109 Some(true)
2110 } else {
2111 None
2112 };
2113 let instrument_id = self.config.instrument_id;
2114 let time_in_force = self.config.open_position_time_in_force;
2115 let quote_quantity = self.config.use_quote_quantity;
2116
2117 let order = self.order_factory().market(
2118 instrument_id,
2119 order_side,
2120 quantity,
2121 Some(time_in_force),
2122 reduce_only,
2123 Some(quote_quantity),
2124 None, None, None, None, );
2129
2130 self.submit_order_apply_params(order)
2131 }
2132
2133 pub(super) fn cancel_active_orders(
2134 &mut self,
2135 instrument_id: InstrumentId,
2136 strategy_id: StrategyId,
2137 client_id: Option<ClientId>,
2138 ) {
2139 let bracket_targets: Vec<ClientOrderId> = {
2142 let cache = self.cache();
2143 let mut targets = Vec::new();
2144
2145 for order_list in
2146 cache.order_lists(None, Some(&instrument_id), Some(&strategy_id), None)
2147 {
2148 let is_bracket = order_list.client_order_ids.iter().any(|cid| {
2149 cache
2150 .order(cid)
2151 .is_some_and(|o| is_in_contingency_group(&o))
2152 });
2153
2154 if !is_bracket {
2155 continue;
2156 }
2157
2158 for cid in &order_list.client_order_ids {
2159 if let Some(order) = cache.order(cid)
2160 && !order.is_closed()
2161 && !order.is_pending_cancel()
2162 {
2163 targets.push(*cid);
2164 }
2165 }
2166 }
2167 targets
2168 };
2169
2170 for cid in bracket_targets {
2171 if let Err(e) = self.cancel_order(cid, client_id, None) {
2172 log::error!("Failed to cancel bracket leg {cid}: {e}");
2173 }
2174 }
2175
2176 if self.config.use_individual_cancels_on_stop {
2177 for cid in self.collect_cancellable_order_ids(instrument_id, strategy_id) {
2178 if let Err(e) = self.cancel_order(cid, client_id, None) {
2179 log::error!("Failed to cancel order {cid}: {e}");
2180 }
2181 }
2182 } else if self.config.use_batch_cancel_on_stop {
2183 let candidates = self.collect_cancellable_orders(instrument_id, strategy_id);
2184 let mut batchable: Vec<ClientOrderId> = Vec::new();
2185
2186 for order in candidates {
2187 let cid = order.client_order_id();
2188 if order.is_emulated() || order.is_active_local() {
2189 if let Err(e) = self.cancel_order(cid, client_id, None) {
2190 log::error!("Failed to cancel local order {cid}: {e}");
2191 }
2192 } else {
2193 batchable.push(cid);
2194 }
2195 }
2196
2197 if !batchable.is_empty()
2198 && let Err(e) = self.cancel_orders(batchable, client_id, None)
2199 {
2200 log::error!("Failed to batch cancel orders: {e}");
2201 }
2202 } else {
2203 let local_ids: Vec<ClientOrderId> = {
2206 let cache = self.cache();
2207 cache
2208 .orders_active_local(None, Some(&instrument_id), Some(&strategy_id), None, None)
2209 .into_iter()
2210 .filter(|o| {
2211 !o.is_closed() && !o.is_pending_cancel() && !is_in_contingency_group(o)
2212 })
2213 .map(|o| o.client_order_id())
2214 .collect()
2215 };
2216
2217 for cid in local_ids {
2218 if let Err(e) = self.cancel_order(cid, client_id, None) {
2219 log::error!("Failed to cancel active-local order {cid}: {e}");
2220 }
2221 }
2222
2223 if let Err(e) = self.cancel_all_orders(instrument_id, None, client_id, false, None) {
2224 log::error!("Failed to cancel all orders: {e}");
2225 }
2226 }
2227 }
2228
2229 pub(super) fn collect_cancellable_orders(
2230 &self,
2231 instrument_id: InstrumentId,
2232 strategy_id: StrategyId,
2233 ) -> Vec<OrderAny> {
2234 let cache = self.cache();
2235 let mut seen: AHashSet<ClientOrderId> = AHashSet::new();
2236 let mut candidates: Vec<OrderAny> = Vec::new();
2237 let sources = [
2240 cache.orders_active_local(None, Some(&instrument_id), Some(&strategy_id), None, None),
2241 cache.orders_emulated(None, Some(&instrument_id), Some(&strategy_id), None, None),
2242 cache.orders_inflight(None, Some(&instrument_id), Some(&strategy_id), None, None),
2243 cache.orders_open(None, Some(&instrument_id), Some(&strategy_id), None, None),
2244 ];
2245
2246 for orders in sources {
2247 for order in orders {
2248 if order.is_closed() || order.is_pending_cancel() || is_in_contingency_group(&order)
2249 {
2250 continue;
2251 }
2252 let cid = order.client_order_id();
2253 if seen.insert(cid) {
2254 candidates.push(order);
2255 }
2256 }
2257 }
2258 candidates
2259 }
2260
2261 pub(super) fn collect_cancellable_order_ids(
2262 &self,
2263 instrument_id: InstrumentId,
2264 strategy_id: StrategyId,
2265 ) -> Vec<ClientOrderId> {
2266 self.collect_cancellable_orders(instrument_id, strategy_id)
2267 .into_iter()
2268 .map(|o| o.client_order_id())
2269 .collect()
2270 }
2271}
2272
2273impl LimitOrderMaintenanceState {
2274 const fn new(enabled: bool) -> Self {
2275 if enabled { Self::Ready } else { Self::Disabled }
2276 }
2277
2278 const fn client_order_id(self) -> Option<ClientOrderId> {
2279 match self {
2280 Self::AwaitingAcceptance { client_order_id }
2281 | Self::Active { client_order_id }
2282 | Self::AwaitingUpdate {
2283 client_order_id, ..
2284 }
2285 | Self::AwaitingCancel {
2286 client_order_id, ..
2287 }
2288 | Self::AwaitingReplacementAcceptance {
2289 client_order_id, ..
2290 } => Some(client_order_id),
2291 Self::Disabled | Self::Ready | Self::Completed | Self::Failed => None,
2292 }
2293 }
2294}
2295
2296fn split_position_quantity(
2297 quantity: Quantity,
2298 precision: u8,
2299) -> anyhow::Result<(Quantity, Decimal)> {
2300 let quantity_decimal = quantity.as_decimal();
2301 let close_decimal = quantity_decimal.trunc_with_scale(u32::from(precision));
2302 let close_quantity = Quantity::from_decimal_dp(close_decimal, quantity.precision)
2303 .map_err(|e| anyhow::anyhow!("Invalid position close quantity {close_decimal}: {e}"))?;
2304 let residual = quantity_decimal - close_quantity.as_decimal();
2305 Ok((close_quantity, residual))
2306}
2307
2308fn add_price_ticks(base: Price, increment: Price, ticks: u64, precision: u8) -> Price {
2309 let offset = price_tick_offset(increment, ticks, precision);
2310 base + offset
2311}
2312
2313fn sub_price_ticks(base: Price, increment: Price, ticks: u64, precision: u8) -> Price {
2314 let offset = price_tick_offset(increment, ticks, precision);
2315 base - offset
2316}
2317
2318fn price_tick_offset(increment: Price, ticks: u64, precision: u8) -> Price {
2319 let offset = increment * Decimal::from(ticks);
2320 Price::from_decimal_dp(offset, precision)
2321 .unwrap_or_else(|e| panic!("Failed to calculate price tick offset: {e}"))
2322}
2323
2324fn is_in_contingency_group(order: &OrderAny) -> bool {
2325 matches!(
2326 order.contingency_type(),
2327 Some(ContingencyType::Oto | ContingencyType::Oco | ContingencyType::Ouo)
2328 )
2329}
2330
2331fn clamp_price_to_range(price: Price, instrument: &InstrumentAny, enabled: bool) -> Price {
2332 if !enabled {
2333 return price;
2334 }
2335 let mut clamped = price;
2336 if let Some(min) = instrument.min_price()
2337 && clamped < min
2338 {
2339 clamped = min;
2340 }
2341
2342 if let Some(max) = instrument.max_price()
2343 && clamped > max
2344 {
2345 clamped = max;
2346 }
2347
2348 clamped
2349}
2350
2351#[derive(Debug)]
2352struct StopOrderReplacement {
2353 client_order_id: ClientOrderId,
2354 trigger_price: Price,
2355 limit_price: Option<Price>,
2356}