Skip to main content

nautilus_testkit/testers/exec/
strategy.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16use std::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/// An execution tester strategy for live testing order execution functionality.
50///
51/// This strategy is designed for testing execution adapters by submitting
52/// limit orders, stop orders, and managing positions. It can maintain orders
53/// at a configurable offset from the top of book.
54///
55/// **WARNING**: This strategy has no alpha advantage whatsoever.
56/// It is not intended to be used for live trading with real money.
57#[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    // Order tracking
70    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    // One-shot guard for `test_modify_rejected`: ensures the programmatic
77    // modify is attempted at most once across the strategy's lifetime.
78    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            // Also subscribe to market data to trigger instrument definitions from data providers
206            // (e.g., Databento sends instrument definitions as part of market data subscriptions)
207            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            // Log own order book if available
326            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(()); // Wait for market
340        };
341        let Some(best_ask) = book.best_ask_price() else {
342            return Ok(()); // Wait for market
343        };
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    /// Creates a new [`ExecTester`] instance.
388    #[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    /// Submit an order, applying `order_params` if configured.
592    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    /// Maintain orders based on current market prices.
602    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    /// Refreshes the locally-tracked order for `side` from the cache so that
633    /// downstream checks (`venue_order_id()`, `is_pending_*`, status) see the
634    /// latest event-driven state instead of the stale clone captured at submit.
635    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    /// Maintain buy limit orders.
670    fn maintain_buy_orders(&mut self, best_bid: Price, best_ask: Price) {
671        // Refresh from cache first so post-submit event state (venue_order_id,
672        // status) is visible. Done before binding `&self.instrument` to avoid
673        // holding an immutable borrow across the mutable refresh call.
674        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            // One-shot programmatic modify to exercise the adapter's modify-rejection
714            // path (TC-E36). Uses a small price bump rather than waiting for drift.
715            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    /// Maintain sell limit orders.
761    fn maintain_sell_orders(&mut self, best_bid: Price, best_ask: Price) {
762        // Refresh from cache before borrowing `&self.instrument`; see the
763        // matching comment in `maintain_buy_orders`.
764        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            // One-shot programmatic modify (TC-E36); see maintain_buy_orders.
804            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    /// Submits a buy and sell limit order as an order list (batch).
1127    fn maintain_batch_limit_pair(&mut self, best_bid: Price, best_ask: Price) {
1128        // Same rationale as the non-batch path: refresh from cache so the
1129        // active-order check sees the latest status. Done before binding
1130        // `&self.instrument` to avoid an immutable-vs-mutable borrow conflict.
1131        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    /// Maintain stop buy orders.
1248    fn maintain_stop_buy_orders(&mut self, best_bid: Price, best_ask: Price) {
1249        self.refresh_tracked_stop_order(OrderSide::Buy);
1250
1251        // Avoid churn: leave a rejected/denied stop alone (no resubmit or modify)
1252        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        // Determine trigger price based on order type
1267        let unclamped_trigger_price = if matches!(
1268            self.config.stop_order_type,
1269            OrderType::LimitIfTouched | OrderType::MarketIfTouched | OrderType::TrailingStopMarket
1270        ) {
1271            // IF_TOUCHED and trailing-stop buy: place BELOW market
1272            sub_price_ticks(best_bid, increment, stop_offset_ticks, precision)
1273        } else {
1274            // STOP buy orders are placed ABOVE the market (stop loss on short)
1275            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        // Calculate limit price if needed
1281        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                    // BUY LIT/StopLimit both require trigger_price <= price.
1288                    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    /// Maintain stop sell orders.
1345    fn maintain_stop_sell_orders(&mut self, best_bid: Price, best_ask: Price) {
1346        self.refresh_tracked_stop_order(OrderSide::Sell);
1347
1348        // Avoid churn: leave a rejected/denied stop alone (no resubmit or modify)
1349        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        // Determine trigger price based on order type
1364        let unclamped_trigger_price = if matches!(
1365            self.config.stop_order_type,
1366            OrderType::LimitIfTouched | OrderType::MarketIfTouched | OrderType::TrailingStopMarket
1367        ) {
1368            // IF_TOUCHED and trailing-stop sell: place ABOVE market
1369            add_price_ticks(best_ask, increment, stop_offset_ticks, precision)
1370        } else {
1371            // STOP sell orders are placed BELOW the market (stop loss on long)
1372            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        // Calculate limit price if needed
1378        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                    // SELL LIT/StopLimit both require trigger_price >= price.
1385                    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    /// Submit a limit order.
1540    ///
1541    /// # Errors
1542    ///
1543    /// Returns an error if order creation or submission fails.
1544    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, // reduce_only
1632            Some(quote_quantity),
1633            display_qty,
1634            emulation_trigger,
1635            None, // trigger_instrument_id
1636            None, // exec_algorithm_id
1637            None, // exec_algorithm_params
1638            None, // tags
1639            None, // client_order_id
1640        );
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    /// Submit a stop order.
1666    ///
1667    /// # Errors
1668    ///
1669    /// Returns an error if order creation or submission fails.
1670    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, // reduce_only
1742                Some(quote_quantity),
1743                None, // display_qty
1744                emulation_trigger,
1745                None, // trigger_instrument_id
1746                None, // exec_algorithm_id
1747                None, // exec_algorithm_params
1748                None, // tags
1749                None, // client_order_id
1750            ),
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, // post_only
1765                    None, // reduce_only
1766                    Some(quote_quantity),
1767                    display_qty,
1768                    emulation_trigger,
1769                    None, // trigger_instrument_id
1770                    None, // exec_algorithm_id
1771                    None, // exec_algorithm_params
1772                    None, // tags
1773                    None, // client_order_id
1774                )
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, // reduce_only
1785                Some(quote_quantity),
1786                emulation_trigger,
1787                None, // trigger_instrument_id
1788                None, // exec_algorithm_id
1789                None, // exec_algorithm_params
1790                None, // tags
1791                None, // client_order_id
1792            ),
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, // post_only
1807                    None, // reduce_only
1808                    Some(quote_quantity),
1809                    display_qty,
1810                    emulation_trigger,
1811                    None, // trigger_instrument_id
1812                    None, // exec_algorithm_id
1813                    None, // exec_algorithm_params
1814                    None, // tags
1815                    None, // client_order_id
1816                )
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, // reduce_only
1834                    Some(quote_quantity),
1835                    None, // display_qty
1836                    emulation_trigger,
1837                    None, // trigger_instrument_id
1838                    None, // exec_algorithm_id
1839                    None, // exec_algorithm_params
1840                    None, // tags
1841                    None, // client_order_id
1842                )
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    /// Submit a bracket order (entry with stop-loss and take-profit).
1864    ///
1865    /// # Errors
1866    ///
1867    /// Returns an error if order creation or submission fails.
1868    #[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    /// Open a position with a market order.
2080    ///
2081    /// # Errors
2082    ///
2083    /// Returns an error if order creation or submission fails.
2084    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        // Test reduce_only rejection by setting reduce_only on open position order
2108        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, // exec_algorithm_id
2125            None, // exec_algorithm_params
2126            None, // tags
2127            None, // client_order_id
2128        );
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        // Reach INITIALIZED contingent legs that the open/emulated/inflight indexes
2140        // miss. Skip non-bracket lists so the configured cancel mode owns them.
2141        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            // `cancel_all_orders` does not reach active-local orders; cancel those
2204            // individually first. Brackets are handled by the sweep above.
2205            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        // `orders_active_local` catches just-submitted orders not yet in the other
2238        // indexes. Bracket legs are excluded; the sweep in `cancel_active_orders` owns them.
2239        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}