Skip to main content

nautilus_trading/algorithm/
twap.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
16//! Time-Weighted Average Price (TWAP) execution algorithm.
17//!
18//! The TWAP algorithm executes orders by evenly spreading them over a specified
19//! time horizon at regular intervals. This helps reduce market impact by avoiding
20//! concentration of trade size at any given time.
21//!
22//! # Parameters
23//!
24//! Orders submitted to this algorithm must include `exec_algorithm_params` with:
25//! - `horizon_secs`: Total execution horizon in seconds.
26//! - `interval_secs`: Interval between child orders in seconds.
27//!
28//! # Example
29//!
30//! An order with `horizon_secs=60` and `interval_secs=10` will spawn 6 child
31//! orders over 60 seconds, one every 10 seconds.
32
33use std::time::Duration;
34
35use ahash::AHashMap;
36use nautilus_common::{
37    actor::{DataActor, DataActorNative},
38    timer::TimeEvent,
39};
40use nautilus_model::{
41    enums::OrderType,
42    events::OrderDeniedReason,
43    identifiers::ClientOrderId,
44    instruments::Instrument,
45    orders::{Order, OrderAny},
46    types::Quantity,
47};
48use rust_decimal::{Decimal, RoundingStrategy};
49use ustr::Ustr;
50
51use super::{
52    ExecutionAlgorithm, ExecutionAlgorithmConfig, ExecutionAlgorithmCore, ExecutionAlgorithmNative,
53};
54use crate::nautilus_execution_algorithm;
55
56/// Configuration for [`TwapAlgorithm`].
57pub type TwapAlgorithmConfig = ExecutionAlgorithmConfig;
58
59/// Time-Weighted Average Price (TWAP) execution algorithm.
60///
61/// Executes orders by evenly spreading them over a specified time horizon,
62/// at regular intervals. The algorithm receives a primary order and spawns
63/// smaller child orders that are executed at regular intervals.
64#[derive(Debug)]
65pub struct TwapAlgorithm {
66    /// The algorithm core.
67    pub core: ExecutionAlgorithmCore,
68    /// Schedules for each primary order.
69    scheduled_orders: AHashMap<ClientOrderId, TwapSchedule>,
70}
71
72impl TwapAlgorithm {
73    /// Creates a new [`TwapAlgorithm`] instance.
74    #[must_use]
75    pub fn new(config: TwapAlgorithmConfig) -> Self {
76        Self {
77            core: ExecutionAlgorithmCore::new(config),
78            scheduled_orders: AHashMap::new(),
79        }
80    }
81
82    /// Completes the execution sequence for a primary order.
83    fn complete_sequence(&mut self, primary_id: ClientOrderId) {
84        let timer_name = primary_id.as_str();
85        let core = ExecutionAlgorithmNative::exec_algorithm_core_mut(self);
86        if core.clock_mut().timer_names().contains(&timer_name) {
87            core.clock_mut().cancel_timer(timer_name);
88        }
89        core.remove_submit_params(&primary_id);
90        self.scheduled_orders.remove(&primary_id);
91        log::info!("Completed TWAP execution for {primary_id}");
92    }
93}
94
95// The clock and component lifecycle dispatch through the `DataActor` hooks,
96// so forward them to the `ExecutionAlgorithm` implementations.
97impl DataActor for TwapAlgorithm {
98    fn on_time_event(&mut self, event: &TimeEvent) -> anyhow::Result<()> {
99        ExecutionAlgorithm::on_time_event(self, event)
100    }
101
102    fn on_stop(&mut self) -> anyhow::Result<()> {
103        ExecutionAlgorithm::on_stop(self)
104    }
105
106    fn on_resume(&mut self) -> anyhow::Result<()> {
107        ExecutionAlgorithm::on_resume(self)
108    }
109
110    fn on_reset(&mut self) -> anyhow::Result<()> {
111        ExecutionAlgorithm::on_reset(self)
112    }
113}
114
115nautilus_execution_algorithm!(TwapAlgorithm, {
116    fn on_order(&mut self, order: OrderAny) -> anyhow::Result<()> {
117        let primary_id = order.client_order_id();
118
119        if self.scheduled_orders.contains_key(&primary_id) {
120            anyhow::bail!("Order {primary_id} already being executed");
121        }
122
123        log::info!("Received order for TWAP execution: {order:?}");
124
125        // Only market orders supported
126        if order.order_type() != OrderType::Market {
127            let reason = OrderDeniedReason::UnsupportedOrderType {
128                order_type: order.order_type(),
129            }
130            .to_string();
131            return self.deny_order(&order, Ustr::from(&reason));
132        }
133
134        let instrument = {
135            let cache = ExecutionAlgorithmNative::exec_algorithm_core(self).cache_ref();
136            cache.instrument(&order.instrument_id()).cloned()
137        };
138
139        let Some(instrument) = instrument else {
140            let reason = OrderDeniedReason::InstrumentNotFound {
141                instrument_id: order.instrument_id(),
142            }
143            .to_string();
144            return self.deny_order(&order, Ustr::from(&reason));
145        };
146
147        let Some(exec_params) = order.exec_algorithm_params() else {
148            return self.deny_order(&order, validation_failed("exec_algorithm_params not found"));
149        };
150
151        let Some(horizon_secs_str) = exec_params.get(&Ustr::from("horizon_secs")) else {
152            return self.deny_order(
153                &order,
154                validation_failed("horizon_secs not found in exec_algorithm_params"),
155            );
156        };
157
158        let horizon_secs: f64 = match horizon_secs_str.parse() {
159            Ok(value) => value,
160            Err(_) => {
161                return self.deny_order(
162                    &order,
163                    validation_failed(format!(
164                        "horizon_secs={horizon_secs_str} is not a valid number"
165                    )),
166                );
167            }
168        };
169
170        let Some(interval_secs_str) = exec_params.get(&Ustr::from("interval_secs")) else {
171            return self.deny_order(
172                &order,
173                validation_failed("interval_secs not found in exec_algorithm_params"),
174            );
175        };
176
177        let interval_secs: f64 = match interval_secs_str.parse() {
178            Ok(value) => value,
179            Err(_) => {
180                return self.deny_order(
181                    &order,
182                    validation_failed(format!(
183                        "interval_secs={interval_secs_str} is not a valid number"
184                    )),
185                );
186            }
187        };
188
189        if !horizon_secs.is_finite() || horizon_secs <= 0.0 {
190            return self.deny_order(
191                &order,
192                validation_failed(format!(
193                    "horizon_secs={horizon_secs} must be finite and positive"
194                )),
195            );
196        }
197
198        if !interval_secs.is_finite() || interval_secs <= 0.0 {
199            return self.deny_order(
200                &order,
201                validation_failed(format!(
202                    "interval_secs={interval_secs} must be finite and positive"
203                )),
204            );
205        }
206
207        if horizon_secs < interval_secs {
208            return self.deny_order(
209                &order,
210                validation_failed(format!(
211                    "horizon_secs={horizon_secs} must be greater than or equal to interval_secs={interval_secs}"
212                )),
213            );
214        }
215
216        let num_intervals = (horizon_secs / interval_secs).floor() as u64;
217        if num_intervals == 0 {
218            return self.deny_order(&order, validation_failed("num_intervals is 0"));
219        }
220
221        let total_qty = order.quantity();
222        let interval_count = Decimal::from(num_intervals);
223        let quotient = total_qty.as_decimal() / interval_count;
224        let floored = quotient.round_dp_with_strategy(
225            u32::from(instrument.size_precision()),
226            RoundingStrategy::ToZero,
227        );
228        let qty_per_interval = match instrument.try_make_qty_from_decimal(floored, None) {
229            Ok(quantity) => quantity,
230            Err(e) => {
231                return self.deny_order(
232                    &order,
233                    validation_failed(format!("invalid qty_per_interval={floored}: {e}")),
234                );
235            }
236        };
237        let remainder = total_qty.as_decimal() - floored * interval_count;
238
239        if qty_per_interval == total_qty || qty_per_interval < instrument.size_increment() {
240            log::warn!(
241                "Submitting for entire size: qty_per_interval={qty_per_interval}, order_quantity={total_qty}"
242            );
243            self.submit_order(order, None, None)?;
244            self.complete_sequence(primary_id);
245            return Ok(());
246        }
247
248        if let Some(min_qty) = instrument.min_quantity()
249            && qty_per_interval < min_qty
250        {
251            log::warn!(
252                "Submitting for entire size: qty_per_interval={qty_per_interval} < min_quantity={min_qty}"
253            );
254            self.submit_order(order, None, None)?;
255            self.complete_sequence(primary_id);
256            return Ok(());
257        }
258
259        let interval = match Duration::try_from_secs_f64(interval_secs) {
260            Ok(interval) => interval,
261            Err(e) => {
262                return self.deny_order(
263                    &order,
264                    validation_failed(format!(
265                        "interval_secs={interval_secs} is not a valid duration: {e}"
266                    )),
267                );
268            }
269        };
270
271        if interval == Duration::ZERO {
272            return self.deny_order(
273                &order,
274                validation_failed(format!(
275                    "interval_secs={interval_secs} rounds to a zero duration"
276                )),
277            );
278        }
279        let Ok(interval_ns) = u64::try_from(interval.as_nanos()) else {
280            return self.deny_order(
281                &order,
282                validation_failed(format!(
283                    "interval_secs={interval_secs} exceeds the clock nanosecond range"
284                )),
285            );
286        };
287        let timestamp_ns = ExecutionAlgorithmNative::exec_algorithm_core_mut(self)
288            .clock_mut()
289            .timestamp_ns()
290            .as_u64();
291
292        if timestamp_ns.checked_add(interval_ns).is_none() {
293            return self.deny_order(
294                &order,
295                validation_failed(format!(
296                    "interval_secs={interval_secs} exceeds the clock timestamp headroom"
297                )),
298            );
299        }
300
301        let mut scheduled_sizes: Vec<Quantity> = vec![qty_per_interval; num_intervals as usize];
302
303        if remainder > Decimal::ZERO {
304            let remainder_qty = match instrument.try_make_qty_from_decimal(remainder, None) {
305                Ok(quantity) => quantity,
306                Err(e) => {
307                    return self.deny_order(
308                        &order,
309                        validation_failed(format!("invalid qty_remainder={remainder}: {e}")),
310                    );
311                }
312            };
313            scheduled_sizes.push(remainder_qty);
314        }
315
316        let scheduled_total = scheduled_sizes
317            .iter()
318            .fold(Decimal::ZERO, |total, quantity| {
319                total + quantity.as_decimal()
320            });
321
322        if scheduled_total != total_qty.as_decimal() {
323            return self.deny_order(
324                &order,
325                validation_failed(format!(
326                    "scheduled quantity {scheduled_total} does not equal order quantity {total_qty}"
327                )),
328            );
329        }
330
331        log::info!("Order execution size schedule: {scheduled_sizes:?}");
332
333        // Add primary order to cache so on_time_event can retrieve it,
334        // it is already present when routed through the engine's submit path.
335        {
336            let cache_rc = ExecutionAlgorithmNative::exec_algorithm_core(self).cache_rc();
337            let mut cache = cache_rc.borrow_mut();
338            if !cache.order_exists(&primary_id) {
339                cache.add_order(order.clone(), None, None, false)?;
340            }
341        }
342
343        ExecutionAlgorithmNative::exec_algorithm_core_mut(self)
344            .clock_mut()
345            .set_timer(primary_id.as_str(), interval, None, None, None, None, None)?;
346
347        self.scheduled_orders.insert(
348            primary_id,
349            TwapSchedule {
350                remaining_sizes: scheduled_sizes,
351                interval,
352                pending_order: None,
353            },
354        );
355        self.submit_slice(order)?;
356
357        log::info!(
358            "Started TWAP execution for {primary_id}: horizon_secs={horizon_secs}, interval_secs={interval_secs}"
359        );
360
361        Ok(())
362    }
363
364    fn on_time_event(&mut self, event: &TimeEvent) -> anyhow::Result<()> {
365        log::info!("Received time event: {event}");
366
367        let primary_id = ClientOrderId::new(event.name);
368
369        let primary = {
370            let cache = ExecutionAlgorithmNative::exec_algorithm_core(self).cache_ref();
371            cache.order(&primary_id).map(|o| o.clone())
372        };
373
374        let Some(primary) = primary else {
375            log::error!("Cannot find primary order for exec_spawn_id={primary_id}");
376            self.complete_sequence(primary_id);
377            return Ok(());
378        };
379
380        if primary.is_closed() {
381            self.complete_sequence(primary_id);
382            return Ok(());
383        }
384
385        self.submit_slice(primary)
386    }
387
388    fn on_stop(&mut self) -> anyhow::Result<()> {
389        ExecutionAlgorithmNative::exec_algorithm_core_mut(self)
390            .clock_mut()
391            .cancel_timers();
392        Ok(())
393    }
394
395    fn on_resume(&mut self) -> anyhow::Result<()> {
396        let primary_ids: Vec<ClientOrderId> = self.scheduled_orders.keys().copied().collect();
397
398        for primary_id in primary_ids {
399            let primary_is_open = {
400                let cache = ExecutionAlgorithmNative::exec_algorithm_core(self).cache_ref();
401                cache.order(&primary_id).map(|primary| !primary.is_closed())
402            };
403
404            if primary_is_open.is_none() {
405                log::error!("Cannot find primary order for exec_spawn_id={primary_id}");
406            }
407            let interval = self.scheduled_orders.get(&primary_id).and_then(|schedule| {
408                (!schedule.remaining_sizes.is_empty()).then_some(schedule.interval)
409            });
410
411            let Some(interval) = interval.filter(|_| primary_is_open == Some(true)) else {
412                self.complete_sequence(primary_id);
413                continue;
414            };
415
416            ExecutionAlgorithmNative::exec_algorithm_core_mut(self)
417                .clock_mut()
418                .set_timer(primary_id.as_str(), interval, None, None, None, None, None)?;
419        }
420
421        Ok(())
422    }
423
424    fn on_reset(&mut self) -> anyhow::Result<()> {
425        self.unsubscribe_all_strategy_events();
426        ExecutionAlgorithmNative::exec_algorithm_core_mut(self).reset();
427        self.scheduled_orders.clear();
428        Ok(())
429    }
430});
431
432impl TwapAlgorithm {
433    fn submit_slice(&mut self, mut primary: OrderAny) -> anyhow::Result<()> {
434        let primary_id = primary.client_order_id();
435
436        let Some(schedule) = self.scheduled_orders.get_mut(&primary_id) else {
437            log::error!("Cannot find scheduled sizes for exec_spawn_id={primary_id}");
438            return Ok(());
439        };
440
441        let Some(quantity) = schedule.remaining_sizes.first().copied() else {
442            log::warn!("No more size to execute for exec_spawn_id={primary_id}");
443            return Ok(());
444        };
445
446        if schedule.remaining_sizes.len() == 1 {
447            self.submit_order(primary, None, None)?;
448            self.complete_sequence(primary_id);
449            return Ok(());
450        }
451
452        let spawned = if let Some(order) = schedule.pending_order.take() {
453            order
454        } else {
455            let tags = primary.tags().map(<[Ustr]>::to_vec);
456            let time_in_force = primary.time_in_force();
457            let reduce_only = primary.is_reduce_only();
458            self.spawn_market(
459                &mut primary,
460                quantity,
461                time_in_force,
462                reduce_only,
463                tags,
464                true,
465            )?
466            .into()
467        };
468
469        let client_order_id = spawned.client_order_id();
470        let order_exists = ExecutionAlgorithmNative::exec_algorithm_core(self)
471            .cache_ref()
472            .order_exists(&client_order_id);
473
474        if let Err(e) = self.submit_order(spawned.clone(), None, None) {
475            self.scheduled_orders
476                .get_mut(&primary_id)
477                .expect("TWAP schedule exists during submission")
478                .pending_order = Some(spawned);
479
480            if !order_exists {
481                // Remove the unannounced cached child so retry publishes initialization
482                ExecutionAlgorithmNative::exec_algorithm_core(self)
483                    .cache_rc()
484                    .borrow_mut()
485                    .purge_order(client_order_id, false)?;
486            }
487
488            return Err(e);
489        }
490
491        self.scheduled_orders
492            .get_mut(&primary_id)
493            .expect("TWAP schedule exists during submission")
494            .remaining_sizes
495            .remove(0);
496        Ok(())
497    }
498}
499
500#[derive(Debug)]
501struct TwapSchedule {
502    remaining_sizes: Vec<Quantity>,
503    interval: Duration,
504    pending_order: Option<OrderAny>,
505}
506
507fn validation_failed(detail: impl Into<String>) -> Ustr {
508    let reason = OrderDeniedReason::ValidationFailed {
509        detail: detail.into(),
510    }
511    .to_string();
512    Ustr::from(&reason)
513}
514
515#[cfg(test)]
516mod tests {
517    use std::{cell::RefCell, rc::Rc};
518
519    use indexmap::IndexMap;
520    use nautilus_common::{
521        cache::Cache,
522        clock::{Clock, VirtualClock},
523        component::Component,
524        enums::ComponentTrigger,
525        messages::execution::{ModifyOrder, SubmitOrder, TradingCommand},
526        msgbus::{self, MessagingSwitchboard, TypedHandler},
527        timer::TimeEventCallback,
528    };
529    use nautilus_core::{DurationNanos, Params, UUID4, UnixNanos};
530    use nautilus_model::{
531        enums::{LiquiditySide, OrderSide, OrderStatus, TimeInForce},
532        events::{
533            OrderDeniedReason, OrderEventAny,
534            order::spec::{OrderAcceptedSpec, OrderCanceledSpec, OrderFilledSpec},
535        },
536        identifiers::{
537            AccountId, ExecAlgorithmId, InstrumentId, StrategyId, TradeId, TraderId, VenueOrderId,
538        },
539        orders::{LimitOrder, MarketOrder},
540        types::{Currency, Price},
541    };
542    use rstest::rstest;
543    use ustr::Ustr;
544
545    use super::*;
546    use crate::cache_database::FailNthAddOrderDatabase;
547
548    fn create_twap_algorithm() -> TwapAlgorithm {
549        // Use unique ID to avoid thread-local registry/msgbus conflicts in parallel tests
550        let unique_id = format!("TWAP-{}", UUID4::new());
551        let config = TwapAlgorithmConfig {
552            exec_algorithm_id: Some(ExecAlgorithmId::new(&unique_id)),
553            ..Default::default()
554        };
555        TwapAlgorithm::new(config)
556    }
557
558    fn register_algorithm_with_clock(algo: &mut TwapAlgorithm) -> Rc<RefCell<VirtualClock>> {
559        let trader_id = TraderId::from("TRADER-001");
560        let clock = Rc::new(RefCell::new(VirtualClock::new()));
561        let cache = Rc::new(RefCell::new(Cache::default()));
562
563        // Register a no-op default handler for timer callbacks
564        clock
565            .borrow_mut()
566            .register_default_handler(TimeEventCallback::Rust(std::sync::Arc::new(|_| {})));
567
568        algo.core.register(trader_id, clock.clone(), cache).unwrap();
569
570        // Transition to Running state for tests
571        algo.transition_state(ComponentTrigger::Initialize).unwrap();
572        algo.transition_state(ComponentTrigger::Start).unwrap();
573        algo.transition_state(ComponentTrigger::StartCompleted)
574            .unwrap();
575
576        clock
577    }
578
579    fn register_algorithm(algo: &mut TwapAlgorithm) {
580        let _ = register_algorithm_with_clock(algo);
581    }
582
583    fn add_instrument_to_cache(algo: &TwapAlgorithm) {
584        use nautilus_model::instruments::{InstrumentAny, stubs::crypto_perpetual_ethusdt};
585
586        let instrument = crypto_perpetual_ethusdt();
587        let cache_rc = algo.core.cache_rc();
588        let mut cache = cache_rc.borrow_mut();
589        cache
590            .add_instrument(InstrumentAny::CryptoPerpetual(instrument))
591            .unwrap();
592    }
593
594    fn create_market_order_with_params(params: IndexMap<Ustr, Ustr>) -> OrderAny {
595        create_market_order_with_params_and_qty(params, Quantity::from("1.0"))
596    }
597
598    fn create_market_order_with_params_and_qty(
599        params: IndexMap<Ustr, Ustr>,
600        quantity: Quantity,
601    ) -> OrderAny {
602        let client_order_id = ClientOrderId::from("O-001");
603        OrderAny::Market(MarketOrder::new(
604            TraderId::from("TRADER-001"),
605            StrategyId::from("STRAT-001"),
606            InstrumentId::from("ETHUSDT-PERP.BINANCE"),
607            client_order_id,
608            OrderSide::Buy,
609            quantity,
610            TimeInForce::Gtc,
611            UUID4::new(),
612            0.into(),
613            false,
614            false,
615            None,
616            None,
617            None,
618            None,
619            Some(ExecAlgorithmId::new("TWAP")),
620            Some(params),
621            Some(client_order_id),
622            None,
623        ))
624    }
625
626    fn assert_twap_denied(algo: &mut TwapAlgorithm, order: &OrderAny, expected_reason: &str) {
627        let strategy_id = order.strategy_id();
628        {
629            let cache_rc = algo.core.cache_rc();
630            cache_rc
631                .borrow_mut()
632                .add_order(order.clone(), None, None, false)
633                .unwrap();
634        }
635        let events = Rc::new(RefCell::new(Vec::new()));
636        let handler = TypedHandler::from({
637            let events = events.clone();
638            move |event: &OrderEventAny| events.borrow_mut().push(event.clone())
639        });
640        let topic = format!("events.order.{strategy_id}");
641        msgbus::subscribe_order_events(topic.clone().into(), handler.clone(), None);
642
643        algo.on_order(order.clone()).unwrap();
644        algo.on_order(order.clone()).unwrap();
645
646        msgbus::unsubscribe_order_events(topic.into(), &handler);
647        let cached_order = algo.cache().order(&order.client_order_id()).unwrap();
648        let events = events.borrow();
649
650        assert_eq!(cached_order.status(), OrderStatus::Denied);
651        assert_eq!(events.len(), 1);
652        assert!(matches!(
653            &events[0],
654            OrderEventAny::Denied(event)
655                if event.reason == expected_reason
656                    && event.strategy_id == strategy_id
657                    && event.client_order_id == order.client_order_id()
658        ));
659        assert!(algo.scheduled_orders.is_empty());
660        assert!(algo.clock().timer_names().is_empty());
661    }
662
663    #[rstest]
664    #[case::initial(2, false)]
665    #[case::intermediate(3, false)]
666    #[case::final_slice(4, false)]
667    #[case::every_slice(2, true)]
668    fn test_twap_slice_persistence_failure_keeps_dispatch(
669        #[case] fail_on: usize,
670        #[case] repeated_failure: bool,
671        #[values(false, true)] stopped: bool,
672    ) {
673        let mut algo = create_twap_algorithm();
674        let clock = register_algorithm_with_clock(&mut algo);
675        let (database, control) = FailNthAddOrderDatabase::create();
676        control.set_fail_add_order_on(Some(fail_on));
677        *algo.core.cache_rc().borrow_mut() = Cache::new(None, Some(Box::new(database)));
678        add_instrument_to_cache(&algo);
679
680        let commands = Rc::new(RefCell::new(Vec::new()));
681
682        let handler = msgbus::TypedIntoHandler::from({
683            let commands = commands.clone();
684            let cache = algo.core.cache_rc();
685            move |command: TradingCommand| {
686                if let TradingCommand::SubmitOrder(command) = command {
687                    let quantity = cache
688                        .borrow()
689                        .order(&command.client_order_id)
690                        .unwrap()
691                        .quantity();
692                    commands
693                        .borrow_mut()
694                        .push((command.client_order_id, quantity, command.params));
695                }
696            }
697        });
698
699        msgbus::register_trading_command_endpoint(
700            MessagingSwitchboard::risk_engine_queue_execute(),
701            handler,
702        );
703        let initialized = Rc::new(RefCell::new(Vec::new()));
704
705        let handler = TypedHandler::from({
706            let initialized = initialized.clone();
707            move |event: &OrderEventAny| {
708                if let OrderEventAny::Initialized(event) = event {
709                    initialized.borrow_mut().push(event.client_order_id);
710                }
711            }
712        });
713
714        let topic = Ustr::from("events.order.STRAT-001");
715        msgbus::subscribe_order_events(topic.as_str().into(), handler.clone(), None);
716
717        let params = IndexMap::from([
718            (Ustr::from("horizon_secs"), Ustr::from("60")),
719            (Ustr::from("interval_secs"), Ustr::from("20")),
720        ]);
721        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
722        let primary_id = order.client_order_id();
723
724        let submit_params = Params::new(
725            [(
726                "routing_profile".to_string(),
727                serde_json::Value::String("persistence-route".to_string()),
728            )]
729            .into(),
730        );
731
732        algo.core
733            .remember_submit_params(primary_id, Some(submit_params.clone()));
734        algo.on_order(order).unwrap();
735        if stopped {
736            Component::stop(&mut algo).unwrap();
737            assert!(algo.clock().timer_names().is_empty());
738            Component::resume(&mut algo).unwrap();
739            assert_eq!(algo.clock().timer_names(), vec![primary_id.as_str()]);
740        }
741
742        for step in 1..3 {
743            if repeated_failure {
744                control.set_fail_add_order_on(Some(1));
745            }
746
747            let events = clock
748                .borrow_mut()
749                .advance_time((step * 20_000_000_000_u64).into(), true);
750            assert_eq!(events.len(), 1);
751            ExecutionAlgorithm::on_time_event(&mut algo, &events[0]).unwrap();
752        }
753
754        msgbus::unsubscribe_order_events(topic.as_str().into(), &handler);
755        let commands = commands.borrow();
756        let ids: Vec<_> = commands.iter().map(|command| command.0).collect();
757        let quantities: Vec<_> = commands.iter().map(|command| command.1).collect();
758        assert_eq!(
759            ids,
760            vec![
761                ClientOrderId::from("O-001-E1"),
762                ClientOrderId::from("O-001-E2"),
763                primary_id
764            ]
765        );
766        assert_eq!(quantities, vec![Quantity::from("0.4"); 3]);
767        assert_eq!(
768            commands
769                .iter()
770                .map(|command| command.2.clone())
771                .collect::<Vec<_>>(),
772            vec![Some(submit_params); 3]
773        );
774        assert_eq!(algo.core.submit_params(&primary_id), None);
775        assert_eq!(
776            quantities.iter().map(Quantity::as_decimal).sum::<Decimal>(),
777            Decimal::from_str_exact("1.2").unwrap()
778        );
779        assert_eq!(
780            *initialized.borrow(),
781            vec![
782                ClientOrderId::from("O-001-E1"),
783                ClientOrderId::from("O-001-E2")
784            ]
785        );
786        assert!(algo.scheduled_orders.is_empty());
787        assert!(algo.clock().timer_names().is_empty());
788        assert!(algo.core.cache_rc().borrow_mut().check_integrity());
789    }
790
791    #[rstest]
792    #[case::pre_cache("60", "1.2", 3)]
793    #[case::single_interval("20", "1.2", 1)]
794    #[case::whole_size("60", "0.001", 1)]
795    fn test_twap_pre_schedule_persistence_failure_keeps_dispatch(
796        #[case] horizon: &str,
797        #[case] quantity: &str,
798        #[case] expected_submissions: usize,
799    ) {
800        let mut algo = create_twap_algorithm();
801        let clock = register_algorithm_with_clock(&mut algo);
802        let (database, control) = FailNthAddOrderDatabase::create();
803        control.set_fail_add_order_on(Some(1));
804        *algo.core.cache_rc().borrow_mut() = Cache::new(None, Some(Box::new(database)));
805        add_instrument_to_cache(&algo);
806        let commands = Rc::new(RefCell::new(Vec::new()));
807
808        let handler = msgbus::TypedIntoHandler::from({
809            let commands = commands.clone();
810            let cache = algo.core.cache_rc();
811            move |command: TradingCommand| {
812                if let TradingCommand::SubmitOrder(command) = command {
813                    let quantity = cache
814                        .borrow()
815                        .order(&command.client_order_id)
816                        .unwrap()
817                        .quantity();
818                    commands
819                        .borrow_mut()
820                        .push((command.client_order_id, quantity));
821                }
822            }
823        });
824
825        msgbus::register_trading_command_endpoint(
826            MessagingSwitchboard::risk_engine_queue_execute(),
827            handler,
828        );
829        let params = IndexMap::from([
830            (Ustr::from("horizon_secs"), Ustr::from(horizon)),
831            (Ustr::from("interval_secs"), Ustr::from("20")),
832        ]);
833        let quantity = Quantity::from(quantity);
834        let order = create_market_order_with_params_and_qty(params, quantity);
835        algo.on_order(order).unwrap();
836
837        for i in 1..expected_submissions {
838            let events = clock
839                .borrow_mut()
840                .advance_time((i as u64 * 20_000_000_000).into(), true);
841            assert_eq!(events.len(), 1);
842            ExecutionAlgorithm::on_time_event(&mut algo, &events[0]).unwrap();
843        }
844
845        let commands = commands.borrow();
846        assert_eq!(commands.len(), expected_submissions);
847        assert_eq!(
848            commands
849                .iter()
850                .map(|command| command.1.as_decimal())
851                .sum::<Decimal>(),
852            quantity.as_decimal()
853        );
854        assert!(algo.scheduled_orders.is_empty());
855        assert!(algo.clock().timer_names().is_empty());
856        assert!(algo.core.cache_rc().borrow_mut().check_integrity());
857    }
858
859    #[rstest]
860    fn test_twap_timer_failure_preserves_primary_for_retry() {
861        let mut algo = create_twap_algorithm();
862        let clock = register_algorithm_with_clock(&mut algo);
863        add_instrument_to_cache(&algo);
864        clock.borrow_mut().cancel_default_handler();
865        let params = IndexMap::from([
866            (Ustr::from("horizon_secs"), Ustr::from("60")),
867            (Ustr::from("interval_secs"), Ustr::from("20")),
868        ]);
869        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
870        let primary_id = order.client_order_id();
871        let result = algo.on_order(order.clone());
872
873        assert_eq!(result.unwrap_err().to_string(), "No callbacks provided");
874        assert!(algo.scheduled_orders.is_empty());
875        assert!(algo.clock().timer_names().is_empty());
876        assert_eq!(
877            algo.cache().order(&primary_id).unwrap().quantity(),
878            Quantity::from("1.2")
879        );
880        assert_eq!(
881            algo.cache()
882                .orders_total_count(None, None, None, None, None),
883            1
884        );
885
886        clock
887            .borrow_mut()
888            .register_default_handler(TimeEventCallback::Rust(std::sync::Arc::new(|_| {})));
889        algo.on_order(order).unwrap();
890
891        assert_eq!(
892            algo.scheduled_orders[&primary_id].remaining_sizes,
893            vec![Quantity::from("0.4"); 2]
894        );
895        assert_eq!(algo.clock().timer_names(), vec![primary_id.as_str()]);
896        assert_eq!(
897            algo.cache().order(&primary_id).unwrap().quantity(),
898            Quantity::from("0.8")
899        );
900        assert_eq!(
901            algo.cache()
902                .orders_total_count(None, None, None, None, None),
903            2
904        );
905    }
906
907    #[rstest]
908    fn test_twap_retry_preserves_closed_child_after_reset() {
909        let mut algo = create_twap_algorithm();
910        let clock = register_algorithm_with_clock(&mut algo);
911        add_instrument_to_cache(&algo);
912        let submitted = Rc::new(RefCell::new(Vec::new()));
913
914        let handler = msgbus::TypedIntoHandler::from({
915            let submitted = submitted.clone();
916            move |command: TradingCommand| {
917                if let TradingCommand::SubmitOrder(command) = command {
918                    submitted.borrow_mut().push(command.client_order_id);
919                }
920            }
921        });
922
923        msgbus::register_trading_command_endpoint(
924            MessagingSwitchboard::risk_engine_queue_execute(),
925            handler,
926        );
927        let params = IndexMap::from([
928            (Ustr::from("horizon_secs"), Ustr::from("60")),
929            (Ustr::from("interval_secs"), Ustr::from("20")),
930        ]);
931        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
932        let primary_id = order.client_order_id();
933        let child_id = ClientOrderId::from("O-001-E1");
934        algo.on_order(order).unwrap();
935        let canceled = OrderCanceledSpec::builder()
936            .trader_id(TraderId::from("TRADER-001"))
937            .strategy_id(StrategyId::from("STRAT-001"))
938            .instrument_id(InstrumentId::from("ETHUSDT-PERP.BINANCE"))
939            .client_order_id(child_id)
940            .build();
941        algo.core
942            .cache_rc()
943            .borrow_mut()
944            .update_order(&OrderEventAny::Canceled(canceled))
945            .unwrap();
946        algo.handle_order_event(OrderEventAny::Canceled(canceled));
947        let closed_child = algo.cache().order(&child_id).unwrap();
948        DataActor::on_reset(&mut algo).unwrap();
949        let primary = algo.cache().order(&primary_id).unwrap();
950
951        let result = algo.on_order(primary);
952        assert_eq!(
953            result.unwrap_err().to_string(),
954            "Order denied: duplicate O-001-E1"
955        );
956        let child = algo.cache().order(&child_id).unwrap();
957        assert_eq!(child.status(), OrderStatus::Canceled);
958        assert_eq!(child.quantity(), Quantity::from("0.4"));
959        assert_eq!(child.events(), closed_child.events());
960        drop(child);
961
962        let events = clock.borrow_mut().advance_time(20_000_000_000.into(), true);
963        assert_eq!(events.len(), 1);
964        let result = ExecutionAlgorithm::on_time_event(&mut algo, &events[0]);
965        assert_eq!(
966            result.unwrap_err().to_string(),
967            "Order denied: duplicate O-001-E1"
968        );
969        assert_eq!(*submitted.borrow(), vec![child_id]);
970        let child = algo.cache().order(&child_id).unwrap();
971        assert_eq!(child.status(), OrderStatus::Canceled);
972        assert_eq!(child.quantity(), Quantity::from("0.4"));
973        assert_eq!(child.events(), closed_child.events());
974        assert!(algo.core.cache_rc().borrow_mut().check_integrity());
975    }
976
977    #[rstest]
978    fn test_twap_creation() {
979        let algo = create_twap_algorithm();
980        assert!(algo.id().inner().starts_with("TWAP"));
981        assert!(algo.scheduled_orders.is_empty());
982    }
983
984    #[rstest]
985    fn test_twap_registration() {
986        let mut algo = create_twap_algorithm();
987        register_algorithm(&mut algo);
988
989        assert_eq!(algo.trader_id(), Some(TraderId::from("TRADER-001")));
990    }
991
992    #[rstest]
993    fn test_twap_reset_clears_scheduled_sizes() {
994        let mut algo = create_twap_algorithm();
995        algo.scheduled_orders.insert(
996            ClientOrderId::new("O-001"),
997            TwapSchedule {
998                remaining_sizes: vec![Quantity::from("1.0")],
999                interval: Duration::from_secs(1),
1000                pending_order: None,
1001            },
1002        );
1003        algo.scheduled_orders.insert(
1004            ClientOrderId::new("O-002"),
1005            TwapSchedule {
1006                remaining_sizes: vec![Quantity::from("2.0")],
1007                interval: Duration::from_secs(2),
1008                pending_order: None,
1009            },
1010        );
1011
1012        assert!(!algo.scheduled_orders.is_empty());
1013
1014        // Dispatch through the DataActor entry point the component lifecycle uses
1015        DataActor::on_reset(&mut algo).unwrap();
1016
1017        assert!(algo.scheduled_orders.is_empty());
1018    }
1019
1020    #[rstest]
1021    fn test_twap_rejects_non_market_orders() {
1022        let mut algo = create_twap_algorithm();
1023        register_algorithm(&mut algo);
1024
1025        let order = OrderAny::Limit(LimitOrder::new(
1026            TraderId::from("TRADER-001"),
1027            StrategyId::from("STRAT-001"),
1028            InstrumentId::from("BTC/USDT.BINANCE"),
1029            ClientOrderId::from("O-001"),
1030            OrderSide::Buy,
1031            Quantity::from("1.0"),
1032            Price::from("50000.0"),
1033            TimeInForce::Gtc,
1034            None,  // expire_time
1035            false, // post_only
1036            false, // reduce_only
1037            false, // quote_quantity
1038            None,  // display_qty
1039            None,  // emulation_trigger
1040            None,  // trigger_instrument_id
1041            None,  // contingency_type
1042            None,  // order_list_id
1043            None,  // linked_order_ids
1044            None,  // parent_order_id
1045            None,  // exec_algorithm_id
1046            None,  // exec_algorithm_params
1047            None,  // exec_spawn_id
1048            None,  // tags
1049            UUID4::new(),
1050            0.into(),
1051        ));
1052
1053        let reason = OrderDeniedReason::UnsupportedOrderType {
1054            order_type: OrderType::Limit,
1055        }
1056        .to_string();
1057        assert_twap_denied(&mut algo, &order, &reason);
1058    }
1059
1060    #[rstest]
1061    fn test_twap_denies_missing_instrument() {
1062        let mut algo = create_twap_algorithm();
1063        register_algorithm(&mut algo);
1064
1065        let mut params = IndexMap::new();
1066        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1067        params.insert(Ustr::from("interval_secs"), Ustr::from("10"));
1068        let order = create_market_order_with_params(params);
1069        let reason = OrderDeniedReason::InstrumentNotFound {
1070            instrument_id: order.instrument_id(),
1071        }
1072        .to_string();
1073
1074        assert_twap_denied(&mut algo, &order, &reason);
1075    }
1076
1077    #[rstest]
1078    fn test_twap_rejects_missing_params() {
1079        let mut algo = create_twap_algorithm();
1080        register_algorithm(&mut algo);
1081
1082        add_instrument_to_cache(&algo);
1083
1084        let order = OrderAny::Market(MarketOrder::new(
1085            TraderId::from("TRADER-001"),
1086            StrategyId::from("STRAT-001"),
1087            InstrumentId::from("ETHUSDT-PERP.BINANCE"),
1088            ClientOrderId::from("O-001"),
1089            OrderSide::Buy,
1090            Quantity::from("1.0"),
1091            TimeInForce::Gtc,
1092            UUID4::new(),
1093            0.into(),
1094            false,
1095            false,
1096            None,
1097            None,
1098            None,
1099            None,
1100            None,
1101            None, // No exec_algorithm_params
1102            None,
1103            None,
1104        ));
1105
1106        assert_twap_denied(
1107            &mut algo,
1108            &order,
1109            "VALIDATION_FAILED: exec_algorithm_params not found",
1110        );
1111    }
1112
1113    #[rstest]
1114    #[case(
1115        None,
1116        Some("10"),
1117        "VALIDATION_FAILED: horizon_secs not found in exec_algorithm_params"
1118    )]
1119    #[case(
1120        Some("60"),
1121        None,
1122        "VALIDATION_FAILED: interval_secs not found in exec_algorithm_params"
1123    )]
1124    #[case(
1125        Some("not-a-number"),
1126        Some("10"),
1127        "VALIDATION_FAILED: horizon_secs=not-a-number is not a valid number"
1128    )]
1129    #[case(
1130        Some("60"),
1131        Some("not-a-number"),
1132        "VALIDATION_FAILED: interval_secs=not-a-number is not a valid number"
1133    )]
1134    fn test_twap_denies_missing_or_malformed_schedule_parameter(
1135        #[case] horizon_secs: Option<&str>,
1136        #[case] interval_secs: Option<&str>,
1137        #[case] expected_reason: &str,
1138    ) {
1139        let mut algo = create_twap_algorithm();
1140        register_algorithm(&mut algo);
1141        add_instrument_to_cache(&algo);
1142
1143        let mut params = IndexMap::new();
1144
1145        if let Some(horizon_secs) = horizon_secs {
1146            params.insert(Ustr::from("horizon_secs"), Ustr::from(horizon_secs));
1147        }
1148
1149        if let Some(interval_secs) = interval_secs {
1150            params.insert(Ustr::from("interval_secs"), Ustr::from(interval_secs));
1151        }
1152
1153        assert_twap_denied(
1154            &mut algo,
1155            &create_market_order_with_params(params),
1156            expected_reason,
1157        );
1158    }
1159
1160    #[rstest]
1161    fn test_twap_rejects_horizon_less_than_interval() {
1162        let mut algo = create_twap_algorithm();
1163        register_algorithm(&mut algo);
1164
1165        add_instrument_to_cache(&algo);
1166
1167        let mut params = IndexMap::new();
1168        params.insert(Ustr::from("horizon_secs"), Ustr::from("30"));
1169        params.insert(Ustr::from("interval_secs"), Ustr::from("60"));
1170
1171        let order = create_market_order_with_params(params);
1172        assert_twap_denied(
1173            &mut algo,
1174            &order,
1175            "VALIDATION_FAILED: horizon_secs=30 must be greater than or equal to interval_secs=60",
1176        );
1177    }
1178
1179    #[rstest]
1180    fn test_twap_rejects_duplicate_order() {
1181        let mut algo = create_twap_algorithm();
1182        register_algorithm(&mut algo);
1183
1184        add_instrument_to_cache(&algo);
1185
1186        let mut params = IndexMap::new();
1187        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1188        params.insert(Ustr::from("interval_secs"), Ustr::from("10"));
1189
1190        let order1 = create_market_order_with_params(params.clone());
1191        let order2 = create_market_order_with_params(params);
1192
1193        algo.on_order(order1).unwrap();
1194        let result = algo.on_order(order2);
1195
1196        assert!(result.is_err());
1197        assert!(
1198            result
1199                .unwrap_err()
1200                .to_string()
1201                .contains("already being executed")
1202        );
1203    }
1204
1205    #[rstest]
1206    fn test_twap_calculates_size_schedule_evenly() {
1207        let mut algo = create_twap_algorithm();
1208        register_algorithm(&mut algo);
1209
1210        add_instrument_to_cache(&algo);
1211
1212        // 1.2 qty over 60s with 20s intervals = 3 intervals of 0.4 each (divides evenly)
1213        let mut params = IndexMap::new();
1214        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1215        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1216
1217        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
1218        let primary_id = order.client_order_id();
1219
1220        algo.on_order(order).unwrap();
1221
1222        // First slice spawned immediately, remaining 2 slices scheduled (no remainder)
1223        let remaining = &algo
1224            .scheduled_orders
1225            .get(&primary_id)
1226            .unwrap()
1227            .remaining_sizes;
1228        assert_eq!(remaining.len(), 2);
1229
1230        for qty in remaining {
1231            assert_eq!(*qty, Quantity::from("0.4"));
1232        }
1233    }
1234
1235    #[rstest]
1236    fn test_twap_reduces_cached_primary_after_first_child_spawn() {
1237        let mut algo = create_twap_algorithm();
1238        register_algorithm(&mut algo);
1239
1240        add_instrument_to_cache(&algo);
1241
1242        let mut params = IndexMap::new();
1243        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1244        params.insert(Ustr::from("interval_secs"), Ustr::from("30"));
1245
1246        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
1247        let primary_id = order.client_order_id();
1248
1249        algo.on_order(order).unwrap();
1250
1251        let cache = algo.cache();
1252        let primary = cache.order(&primary_id).unwrap();
1253        let spawned = cache.order(&ClientOrderId::from("O-001-E1")).unwrap();
1254
1255        assert_eq!(primary.quantity(), Quantity::from("0.6"));
1256        assert_eq!(spawned.quantity(), Quantity::from("0.6"));
1257        assert_eq!(spawned.exec_spawn_id(), Some(primary_id));
1258    }
1259
1260    #[rstest]
1261    fn test_twap_refused_modify_preserves_remaining_quantity_schedule() {
1262        let mut algo = create_twap_algorithm();
1263        register_algorithm(&mut algo);
1264        add_instrument_to_cache(&algo);
1265
1266        let mut params = IndexMap::new();
1267        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1268        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1269        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
1270        let primary_id = order.client_order_id();
1271        algo.on_order(order).unwrap();
1272
1273        let command = ModifyOrder::new(
1274            TraderId::from("TRADER-001"),
1275            None,
1276            StrategyId::from("STRAT-001"),
1277            InstrumentId::from("ETHUSDT-PERP.BINANCE"),
1278            primary_id,
1279            None,
1280            Some(Quantity::from("0.4")),
1281            None,
1282            None,
1283            UUID4::new(),
1284            0.into(),
1285            None,
1286            None,
1287        );
1288
1289        let cause = command.command_id;
1290        let timers_before = algo.clock().timer_names();
1291        let remaining_before = algo.scheduled_orders[&primary_id].remaining_sizes.clone();
1292        let primary_before = algo.cache().order(&primary_id).unwrap();
1293        algo.handle_modify_order(command).unwrap();
1294
1295        let primary_quantity = algo.cache().order(&primary_id).unwrap().quantity();
1296        let scheduled_quantity = algo.scheduled_orders[&primary_id]
1297            .remaining_sizes
1298            .iter()
1299            .fold(Decimal::ZERO, |total, quantity| {
1300                total + quantity.as_decimal()
1301            });
1302
1303        let cached = algo.cache().order(&primary_id).unwrap();
1304
1305        let OrderEventAny::ModifyDenied(event) = cached.last_event() else {
1306            panic!("expected local modify denial");
1307        };
1308
1309        assert_eq!(event.causation_id, Some(cause));
1310        assert_eq!(event.client_order_id, primary_id);
1311        assert_eq!(event.strategy_id, primary_before.strategy_id());
1312        assert_eq!(event.instrument_id, primary_before.instrument_id());
1313        assert_eq!(cached.status(), primary_before.status());
1314        assert_eq!(cached.filled_qty(), primary_before.filled_qty());
1315        assert_eq!(algo.clock().timer_names(), timers_before);
1316        assert_eq!(
1317            algo.scheduled_orders[&primary_id].remaining_sizes,
1318            remaining_before
1319        );
1320        assert_eq!(primary_quantity.as_decimal(), scheduled_quantity);
1321        assert_eq!(primary_quantity, Quantity::from("0.8"));
1322    }
1323
1324    #[rstest]
1325    fn test_twap_on_order_accepts_already_cached_primary() {
1326        let mut algo = create_twap_algorithm();
1327        register_algorithm(&mut algo);
1328
1329        add_instrument_to_cache(&algo);
1330
1331        let mut params = IndexMap::new();
1332        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1333        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1334
1335        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
1336        let primary_id = order.client_order_id();
1337
1338        // The engine submit path caches the primary before routing to the algorithm
1339        {
1340            let cache_rc = algo.core.cache_rc();
1341            let mut cache = cache_rc.borrow_mut();
1342            cache.add_order(order.clone(), None, None, false).unwrap();
1343        }
1344
1345        algo.on_order(order).unwrap();
1346
1347        assert_eq!(algo.scheduled_orders[&primary_id].remaining_sizes.len(), 2);
1348    }
1349
1350    #[rstest]
1351    fn test_twap_calculates_size_schedule_with_remainder() {
1352        let mut algo = create_twap_algorithm();
1353        register_algorithm(&mut algo);
1354
1355        add_instrument_to_cache(&algo);
1356        let instrument = nautilus_model::instruments::stubs::crypto_perpetual_ethusdt();
1357
1358        // 1.0 qty over 60s with 20s intervals = 3 intervals
1359        let mut params = IndexMap::new();
1360        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1361        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1362
1363        let order = create_market_order_with_params(params);
1364        let primary_id = order.client_order_id();
1365
1366        algo.on_order(order).unwrap();
1367
1368        // First slice spawned, 3 remaining (2 regular + 1 remainder)
1369        let remaining = &algo
1370            .scheduled_orders
1371            .get(&primary_id)
1372            .unwrap()
1373            .remaining_sizes;
1374        assert_eq!(remaining.len(), 3);
1375        assert_eq!(
1376            remaining,
1377            &[
1378                Quantity::from("0.333"),
1379                Quantity::from("0.333"),
1380                Quantity::from("0.001"),
1381            ]
1382        );
1383
1384        for quantity in remaining {
1385            assert_eq!(quantity.precision, instrument.size_precision());
1386            assert_eq!(quantity.raw() % instrument.size_increment().raw(), 0);
1387        }
1388
1389        let first = algo
1390            .cache()
1391            .order(&ClientOrderId::from("O-001-E1"))
1392            .unwrap()
1393            .quantity();
1394        let total = remaining
1395            .iter()
1396            .fold(first.as_decimal(), |sum, qty| sum + qty.as_decimal());
1397        assert_eq!(total, Quantity::from("1.0").as_decimal());
1398    }
1399
1400    #[rstest]
1401    fn test_twap_children_use_instrument_size_precision() {
1402        let mut algo = create_twap_algorithm();
1403        register_algorithm(&mut algo);
1404
1405        add_instrument_to_cache(&algo);
1406        let instrument = nautilus_model::instruments::stubs::crypto_perpetual_ethusdt();
1407
1408        let mut params = IndexMap::new();
1409        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1410        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1411
1412        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.000000000"));
1413        let primary_id = order.client_order_id();
1414
1415        algo.on_order(order).unwrap();
1416
1417        let spawned = algo
1418            .cache()
1419            .order(&ClientOrderId::from("O-001-E1"))
1420            .unwrap()
1421            .quantity();
1422        assert_eq!(spawned.precision, instrument.size_precision());
1423        assert!(
1424            algo.scheduled_orders[&primary_id]
1425                .remaining_sizes
1426                .iter()
1427                .all(|quantity| quantity.precision == instrument.size_precision())
1428        );
1429    }
1430
1431    #[rstest]
1432    fn test_twap_on_time_event_spawns_next_slice() {
1433        let mut algo = create_twap_algorithm();
1434        register_algorithm(&mut algo);
1435
1436        add_instrument_to_cache(&algo);
1437
1438        // Use qty that divides evenly: 1.2 / 3 = 0.4 each
1439        let mut params = IndexMap::new();
1440        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1441        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1442
1443        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
1444        let primary_id = order.client_order_id();
1445
1446        let submit_params = Params::new(
1447            [(
1448                "routing_profile".to_string(),
1449                serde_json::Value::String("intermediate-slice".to_string()),
1450            )]
1451            .into(),
1452        );
1453        algo.core
1454            .remember_submit_params(primary_id, Some(submit_params.clone()));
1455
1456        algo.on_order(order).unwrap();
1457
1458        // Verify 2 slices remain after first spawn (no remainder)
1459        assert_eq!(algo.scheduled_orders[&primary_id].remaining_sizes.len(), 2);
1460
1461        // Simulate timer firing
1462        let event = TimeEvent::new(primary_id.inner(), UUID4::new(), 0.into(), 0.into());
1463        ExecutionAlgorithm::on_time_event(&mut algo, &event).unwrap();
1464
1465        // One slice consumed
1466        assert_eq!(algo.scheduled_orders[&primary_id].remaining_sizes.len(), 1);
1467        assert_eq!(algo.core.submit_params(&primary_id), Some(submit_params));
1468    }
1469
1470    #[rstest]
1471    fn test_twap_data_actor_dispatch_spawns_next_slice() {
1472        let mut algo = create_twap_algorithm();
1473        register_algorithm(&mut algo);
1474
1475        add_instrument_to_cache(&algo);
1476
1477        let mut params = IndexMap::new();
1478        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1479        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1480
1481        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
1482        let primary_id = order.client_order_id();
1483
1484        algo.on_order(order).unwrap();
1485        assert_eq!(algo.scheduled_orders[&primary_id].remaining_sizes.len(), 2);
1486
1487        // Dispatch through the DataActor entry point the clock callback uses
1488        let event = TimeEvent::new(primary_id.inner(), UUID4::new(), 0.into(), 0.into());
1489        algo.handle_time_event(&event);
1490
1491        assert_eq!(algo.scheduled_orders[&primary_id].remaining_sizes.len(), 1);
1492    }
1493
1494    #[rstest]
1495    fn test_twap_on_time_event_completes_on_final_slice() {
1496        let mut algo = create_twap_algorithm();
1497        register_algorithm(&mut algo);
1498
1499        add_instrument_to_cache(&algo);
1500
1501        // 2 intervals: first spawned immediately, one in scheduled_sizes
1502        let mut params = IndexMap::new();
1503        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1504        params.insert(Ustr::from("interval_secs"), Ustr::from("30"));
1505
1506        let order = create_market_order_with_params(params);
1507        let primary_id = order.client_order_id();
1508
1509        let submit_params = Params::new(
1510            [(
1511                "routing_profile".to_string(),
1512                serde_json::Value::String("final-slice".to_string()),
1513            )]
1514            .into(),
1515        );
1516        algo.core
1517            .remember_submit_params(primary_id, Some(submit_params.clone()));
1518
1519        algo.on_order(order).unwrap();
1520        assert_eq!(algo.scheduled_orders[&primary_id].remaining_sizes.len(), 1);
1521        assert_eq!(
1522            algo.core.submit_params(&primary_id),
1523            Some(submit_params.clone())
1524        );
1525
1526        let received = Rc::new(RefCell::new(None::<SubmitOrder>));
1527        let handler = msgbus::TypedIntoHandler::from({
1528            let captured = received.clone();
1529            move |cmd: TradingCommand| {
1530                if let TradingCommand::SubmitOrder(cmd) = cmd {
1531                    *captured.borrow_mut() = Some(cmd);
1532                }
1533            }
1534        });
1535        msgbus::register_trading_command_endpoint(
1536            MessagingSwitchboard::risk_engine_queue_execute(),
1537            handler,
1538        );
1539
1540        // Simulate timer firing for final slice
1541        let event = TimeEvent::new(primary_id.inner(), UUID4::new(), 0.into(), 0.into());
1542        ExecutionAlgorithm::on_time_event(&mut algo, &event).unwrap();
1543
1544        // Sequence completed, scheduled_sizes removed
1545        assert!(algo.scheduled_orders.get(&primary_id).is_none());
1546        assert_eq!(
1547            received
1548                .borrow()
1549                .as_ref()
1550                .and_then(|cmd| cmd.params.clone()),
1551            Some(submit_params),
1552        );
1553        assert_eq!(algo.core.submit_params(&primary_id), None);
1554    }
1555
1556    #[rstest]
1557    fn test_twap_on_time_event_completes_when_primary_closed() {
1558        let mut algo = create_twap_algorithm();
1559        register_algorithm(&mut algo);
1560
1561        add_instrument_to_cache(&algo);
1562
1563        let mut params = IndexMap::new();
1564        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1565        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1566
1567        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
1568        let primary_id = order.client_order_id();
1569
1570        let submit_params = Params::new(
1571            [(
1572                "routing_profile".to_string(),
1573                serde_json::Value::String("closed-primary".to_string()),
1574            )]
1575            .into(),
1576        );
1577        algo.core
1578            .remember_submit_params(primary_id, Some(submit_params));
1579
1580        algo.on_order(order).unwrap();
1581        assert_eq!(algo.scheduled_orders[&primary_id].remaining_sizes.len(), 2);
1582
1583        // Mark primary order as closed (canceled)
1584        {
1585            let cache_rc = algo.core.cache_rc();
1586            let mut cache = cache_rc.borrow_mut();
1587            let primary = cache.order(&primary_id).map(|o| o.clone()).unwrap();
1588
1589            let canceled = OrderCanceledSpec::builder()
1590                .trader_id(primary.trader_id())
1591                .strategy_id(primary.strategy_id())
1592                .instrument_id(primary.instrument_id())
1593                .client_order_id(primary.client_order_id())
1594                .build();
1595            cache
1596                .update_order(&OrderEventAny::Canceled(canceled))
1597                .unwrap();
1598        }
1599
1600        // Timer fires but primary is closed
1601        let event = TimeEvent::new(primary_id.inner(), UUID4::new(), 0.into(), 0.into());
1602        ExecutionAlgorithm::on_time_event(&mut algo, &event).unwrap();
1603
1604        // Sequence should complete early since primary is closed
1605        assert!(algo.scheduled_orders.get(&primary_id).is_none());
1606        assert_eq!(algo.core.submit_params(&primary_id), None);
1607    }
1608
1609    #[rstest]
1610    fn test_twap_on_time_event_completes_when_primary_missing() {
1611        let mut algo = create_twap_algorithm();
1612        register_algorithm(&mut algo);
1613        add_instrument_to_cache(&algo);
1614
1615        let mut params = IndexMap::new();
1616        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1617        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1618
1619        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
1620        let primary_id = order.client_order_id();
1621        algo.on_order(order).unwrap();
1622
1623        {
1624            let cache_rc = algo.core.cache_rc();
1625            let mut cache = cache_rc.borrow_mut();
1626            let primary = cache.order(&primary_id).map(|order| order.clone()).unwrap();
1627            let canceled = OrderCanceledSpec::builder()
1628                .trader_id(primary.trader_id())
1629                .strategy_id(primary.strategy_id())
1630                .instrument_id(primary.instrument_id())
1631                .client_order_id(primary.client_order_id())
1632                .build();
1633            cache
1634                .update_order(&OrderEventAny::Canceled(canceled))
1635                .unwrap();
1636            cache.purge_order(primary_id, false).unwrap();
1637        }
1638        assert!(algo.cache().order(&primary_id).is_none());
1639
1640        let event = TimeEvent::new(primary_id.inner(), UUID4::new(), 0.into(), 0.into());
1641        ExecutionAlgorithm::on_time_event(&mut algo, &event).unwrap();
1642
1643        // A vanished primary is terminal: the schedule must not outlive it and block the ID
1644        assert!(algo.scheduled_orders.get(&primary_id).is_none());
1645        assert!(algo.clock().timer_names().is_empty());
1646    }
1647
1648    #[rstest]
1649    fn test_twap_on_stop_cancels_timers() {
1650        let mut algo = create_twap_algorithm();
1651        register_algorithm(&mut algo);
1652
1653        add_instrument_to_cache(&algo);
1654
1655        let mut params = IndexMap::new();
1656        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1657        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1658
1659        let order = create_market_order_with_params(params);
1660        let primary_id = order.client_order_id();
1661
1662        algo.on_order(order).unwrap();
1663
1664        // Verify timer is set
1665        assert!(
1666            algo.clock()
1667                .timer_names()
1668                .iter()
1669                .any(|name| name.as_str() == primary_id.as_str())
1670        );
1671
1672        // Stop through the DataActor entry point the component lifecycle uses
1673        DataActor::on_stop(&mut algo).unwrap();
1674
1675        // Timer should be canceled
1676        assert!(algo.clock().timer_names().is_empty());
1677        assert_eq!(algo.scheduled_orders[&primary_id].remaining_sizes.len(), 3);
1678    }
1679
1680    #[rstest]
1681    fn test_twap_on_resume_rearms_timer_without_submitting() {
1682        let mut algo = create_twap_algorithm();
1683        register_algorithm(&mut algo);
1684        add_instrument_to_cache(&algo);
1685
1686        let mut params = IndexMap::new();
1687        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1688        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1689
1690        let order = create_market_order_with_params(params);
1691        let primary_id = order.client_order_id();
1692        algo.on_order(order).unwrap();
1693        let order_count = algo
1694            .cache()
1695            .orders_total_count(None, None, None, None, None);
1696
1697        Component::stop(&mut algo).unwrap();
1698
1699        // Observe the command bus directly: resubmitting the already-cached primary would
1700        // leave the order count unchanged, so the count alone cannot prove nothing was sent.
1701        let received = Rc::new(RefCell::new(None::<SubmitOrder>));
1702        let handler = msgbus::TypedIntoHandler::from({
1703            let captured = received.clone();
1704            move |cmd: TradingCommand| {
1705                if let TradingCommand::SubmitOrder(cmd) = cmd {
1706                    *captured.borrow_mut() = Some(cmd);
1707                }
1708            }
1709        });
1710        msgbus::register_trading_command_endpoint(
1711            MessagingSwitchboard::risk_engine_queue_execute(),
1712            handler,
1713        );
1714
1715        let resume_time = algo.clock().timestamp_ns();
1716        Component::resume(&mut algo).unwrap();
1717
1718        assert!(received.borrow().is_none());
1719        assert_eq!(algo.clock().timer_count(), 1);
1720        assert_eq!(
1721            algo.clock().next_time_ns(primary_id.as_str()),
1722            Some(resume_time + DurationNanos::from_secs(20))
1723        );
1724        assert_eq!(algo.scheduled_orders[&primary_id].remaining_sizes.len(), 3);
1725        assert_eq!(
1726            algo.cache()
1727                .orders_total_count(None, None, None, None, None),
1728            order_count
1729        );
1730    }
1731
1732    #[rstest]
1733    fn test_twap_on_resume_executes_remaining_slices() {
1734        let mut algo = create_twap_algorithm();
1735        let clock = register_algorithm_with_clock(&mut algo);
1736        add_instrument_to_cache(&algo);
1737
1738        let mut params = IndexMap::new();
1739        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1740        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1741
1742        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
1743        let primary_id = order.client_order_id();
1744        algo.on_order(order).unwrap();
1745
1746        Component::stop(&mut algo).unwrap();
1747        Component::resume(&mut algo).unwrap();
1748        assert_eq!(algo.clock().timer_count(), 1);
1749
1750        let first_events = clock.borrow_mut().advance_time(20_000_000_000.into(), true);
1751        assert_eq!(first_events.len(), 1);
1752        algo.handle_time_event(&first_events[0]);
1753        assert_eq!(algo.scheduled_orders[&primary_id].remaining_sizes.len(), 1);
1754
1755        let final_events = clock.borrow_mut().advance_time(40_000_000_000.into(), true);
1756        assert_eq!(final_events.len(), 1);
1757        algo.handle_time_event(&final_events[0]);
1758        assert!(algo.scheduled_orders.get(&primary_id).is_none());
1759    }
1760
1761    #[rstest]
1762    #[case::cancel(false, Quantity::from("1.2"), false, 2)]
1763    #[case::late_fill(true, Quantity::from("1.0"), false, 2)]
1764    #[case::cancel_final_persistence_failure(false, Quantity::from("1.2"), true, 2)]
1765    #[case::late_fill_final_persistence_failure(true, Quantity::from("1.0"), true, 2)]
1766    #[case::cancel_intermediate_persistence_failure(false, Quantity::from("0.8"), true, 3)]
1767    #[case::late_fill_intermediate_persistence_failure(true, Quantity::from("0.6"), true, 3)]
1768    fn test_twap_resume_preserves_spawn_accounting(
1769        #[case] late_fill: bool,
1770        #[case] expected_primary_qty: Quantity,
1771        #[case] persistence_failure: bool,
1772        #[case] slices: usize,
1773    ) {
1774        let mut algo = create_twap_algorithm();
1775        let clock = register_algorithm_with_clock(&mut algo);
1776        let (database, control) = FailNthAddOrderDatabase::create();
1777        *algo.core.cache_rc().borrow_mut() = Cache::new(None, Some(Box::new(database)));
1778        add_instrument_to_cache(&algo);
1779        let received = Rc::new(RefCell::new(Vec::new()));
1780
1781        let handler = msgbus::TypedIntoHandler::from({
1782            let received = received.clone();
1783            move |command: TradingCommand| {
1784                if let TradingCommand::SubmitOrder(command) = command {
1785                    received.borrow_mut().push(command);
1786                }
1787            }
1788        });
1789
1790        msgbus::register_trading_command_endpoint(
1791            MessagingSwitchboard::risk_engine_queue_execute(),
1792            handler,
1793        );
1794        let mut params = IndexMap::new();
1795
1796        let horizon = if slices == 3 { "60" } else { "40" };
1797        let interval_ns = 20_000_000_000_u64;
1798        params.insert(Ustr::from("horizon_secs"), Ustr::from(horizon));
1799        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1800        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
1801        let primary_id = order.client_order_id();
1802        algo.on_order(order).unwrap();
1803        let child = algo
1804            .cache()
1805            .order(&received.borrow()[0].client_order_id)
1806            .unwrap();
1807        let accepted = OrderAcceptedSpec::builder()
1808            .trader_id(child.trader_id())
1809            .strategy_id(child.strategy_id())
1810            .instrument_id(child.instrument_id())
1811            .client_order_id(child.client_order_id())
1812            .venue_order_id(VenueOrderId::from("V-CHILD"))
1813            .account_id(AccountId::from("BINANCE-001"))
1814            .build();
1815        algo.core
1816            .cache_rc()
1817            .borrow_mut()
1818            .update_order(&OrderEventAny::Accepted(accepted))
1819            .unwrap();
1820        algo.handle_order_event(OrderEventAny::Accepted(accepted));
1821        let canceled = OrderCanceledSpec::builder()
1822            .trader_id(child.trader_id())
1823            .strategy_id(child.strategy_id())
1824            .instrument_id(child.instrument_id())
1825            .client_order_id(child.client_order_id())
1826            .venue_order_id(accepted.venue_order_id)
1827            .account_id(accepted.account_id)
1828            .build();
1829
1830        if persistence_failure {
1831            control.set_fail_add_order_on(Some(1));
1832        }
1833
1834        if !late_fill {
1835            Component::stop(&mut algo).unwrap();
1836        }
1837
1838        algo.core
1839            .cache_rc()
1840            .borrow_mut()
1841            .update_order(&OrderEventAny::Canceled(canceled))
1842            .unwrap();
1843        algo.handle_order_event(OrderEventAny::Canceled(canceled));
1844        if late_fill {
1845            Component::stop(&mut algo).unwrap();
1846            let filled = OrderFilledSpec::builder()
1847                .trader_id(child.trader_id())
1848                .strategy_id(child.strategy_id())
1849                .instrument_id(child.instrument_id())
1850                .client_order_id(child.client_order_id())
1851                .venue_order_id(accepted.venue_order_id)
1852                .account_id(accepted.account_id)
1853                .trade_id(TradeId::from("TRADE-LATE"))
1854                .order_side(child.order_side())
1855                .order_type(child.order_type())
1856                .last_qty(Quantity::from("0.2"))
1857                .last_px(Price::from("3000.01"))
1858                .currency(Currency::USDT())
1859                .liquidity_side(LiquiditySide::Taker)
1860                .build();
1861            algo.core
1862                .cache_rc()
1863                .borrow_mut()
1864                .update_order(&OrderEventAny::Filled(filled.clone()))
1865                .unwrap();
1866            algo.handle_order_event(OrderEventAny::Filled(filled));
1867        }
1868
1869        Component::resume(&mut algo).unwrap();
1870
1871        let timestamp = interval_ns;
1872        for step in 0..slices - 1 {
1873            let timestamp = timestamp + step as u64 * interval_ns;
1874            let events = clock.borrow_mut().advance_time(timestamp.into(), true);
1875            assert_eq!(events.len(), 1);
1876            algo.handle_time_event(&events[0]);
1877        }
1878
1879        let received = received.borrow();
1880        assert_eq!(received.len(), slices);
1881        let primary = algo
1882            .cache()
1883            .order(&received.last().unwrap().client_order_id)
1884            .unwrap();
1885        let child = algo.cache().order(&child.client_order_id()).unwrap();
1886        assert_eq!(primary.client_order_id(), primary_id);
1887        assert_eq!(primary.quantity(), expected_primary_qty);
1888
1889        let retried_child_qty = received[1..received.len() - 1]
1890            .iter()
1891            .map(|command| {
1892                algo.cache()
1893                    .order(&command.client_order_id)
1894                    .unwrap()
1895                    .quantity()
1896                    .as_decimal()
1897            })
1898            .sum::<Decimal>();
1899
1900        assert_eq!(
1901            child.filled_qty().as_decimal() + retried_child_qty + primary.quantity().as_decimal(),
1902            Quantity::from("1.2").as_decimal()
1903        );
1904        assert!(algo.scheduled_orders.is_empty());
1905        assert!(algo.clock().timer_names().is_empty());
1906    }
1907
1908    #[rstest]
1909    fn test_twap_on_resume_completes_closed_primary() {
1910        let mut algo = create_twap_algorithm();
1911        register_algorithm(&mut algo);
1912        add_instrument_to_cache(&algo);
1913
1914        let mut params = IndexMap::new();
1915        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1916        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1917
1918        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
1919        let primary_id = order.client_order_id();
1920        algo.on_order(order).unwrap();
1921        Component::stop(&mut algo).unwrap();
1922
1923        {
1924            let cache_rc = algo.core.cache_rc();
1925            let mut cache = cache_rc.borrow_mut();
1926            let primary = cache.order(&primary_id).map(|order| order.clone()).unwrap();
1927            let canceled = OrderCanceledSpec::builder()
1928                .trader_id(primary.trader_id())
1929                .strategy_id(primary.strategy_id())
1930                .instrument_id(primary.instrument_id())
1931                .client_order_id(primary.client_order_id())
1932                .build();
1933            cache
1934                .update_order(&OrderEventAny::Canceled(canceled))
1935                .unwrap();
1936        }
1937
1938        Component::resume(&mut algo).unwrap();
1939
1940        assert!(algo.scheduled_orders.get(&primary_id).is_none());
1941        assert_eq!(algo.clock().timer_count(), 0);
1942    }
1943
1944    #[rstest]
1945    fn test_twap_on_resume_completes_missing_primary() {
1946        let mut algo = create_twap_algorithm();
1947        register_algorithm(&mut algo);
1948        add_instrument_to_cache(&algo);
1949
1950        let mut params = IndexMap::new();
1951        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
1952        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
1953
1954        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
1955        let primary_id = order.client_order_id();
1956        algo.on_order(order).unwrap();
1957        Component::stop(&mut algo).unwrap();
1958
1959        {
1960            let cache_rc = algo.core.cache_rc();
1961            let mut cache = cache_rc.borrow_mut();
1962            let primary = cache.order(&primary_id).map(|order| order.clone()).unwrap();
1963            let canceled = OrderCanceledSpec::builder()
1964                .trader_id(primary.trader_id())
1965                .strategy_id(primary.strategy_id())
1966                .instrument_id(primary.instrument_id())
1967                .client_order_id(primary.client_order_id())
1968                .build();
1969            cache
1970                .update_order(&OrderEventAny::Canceled(canceled))
1971                .unwrap();
1972            cache.purge_order(primary_id, false).unwrap();
1973        }
1974
1975        assert!(algo.cache().order(&primary_id).is_none());
1976        Component::resume(&mut algo).unwrap();
1977
1978        assert!(algo.scheduled_orders.get(&primary_id).is_none());
1979        assert_eq!(algo.clock().timer_count(), 0);
1980    }
1981
1982    #[rstest]
1983    fn test_twap_fractional_interval_secs() {
1984        let mut algo = create_twap_algorithm();
1985        register_algorithm(&mut algo);
1986
1987        add_instrument_to_cache(&algo);
1988
1989        // Use fractional interval like Python tests: 3 second horizon, 0.5 second interval
1990        let mut params = IndexMap::new();
1991        params.insert(Ustr::from("horizon_secs"), Ustr::from("3"));
1992        params.insert(Ustr::from("interval_secs"), Ustr::from("0.5"));
1993
1994        let order = create_market_order_with_params(params);
1995        let primary_id = order.client_order_id();
1996
1997        // Should not error - fractional seconds should parse correctly
1998        algo.on_order(order).unwrap();
1999
2000        // 3 / 0.5 = 6 intervals, first spawned immediately, 5 remaining (plus possible remainder)
2001        let remaining = &algo
2002            .scheduled_orders
2003            .get(&primary_id)
2004            .unwrap()
2005            .remaining_sizes;
2006        assert!(remaining.len() >= 5);
2007    }
2008
2009    #[rstest]
2010    fn test_twap_submits_entire_size_when_qty_per_interval_below_size_increment() {
2011        use nautilus_model::instruments::{InstrumentAny, stubs::equity_aapl};
2012
2013        let mut algo = create_twap_algorithm();
2014        register_algorithm(&mut algo);
2015
2016        // Use equity with size_increment of 1 (whole shares only)
2017        let instrument = equity_aapl();
2018        let instrument_id = instrument.id();
2019        {
2020            let cache_rc = algo.core.cache_rc();
2021            let mut cache = cache_rc.borrow_mut();
2022            cache
2023                .add_instrument(InstrumentAny::Equity(instrument))
2024                .unwrap();
2025        }
2026
2027        // 2 shares over 60s with 10s intervals = 6 intervals
2028        // 2 / 6 = 0.333... which is less than size_increment of 1
2029        let mut params = IndexMap::new();
2030        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
2031        params.insert(Ustr::from("interval_secs"), Ustr::from("10"));
2032
2033        let client_order_id = ClientOrderId::from("O-002");
2034        let order = OrderAny::Market(MarketOrder::new(
2035            TraderId::from("TRADER-001"),
2036            StrategyId::from("STRAT-001"),
2037            instrument_id,
2038            client_order_id,
2039            OrderSide::Buy,
2040            Quantity::from("2"),
2041            TimeInForce::Gtc,
2042            UUID4::new(),
2043            0.into(),
2044            false,
2045            false,
2046            None,
2047            None,
2048            None,
2049            None,
2050            Some(ExecAlgorithmId::new("TWAP")),
2051            Some(params),
2052            Some(client_order_id),
2053            None,
2054        ));
2055
2056        let primary_id = order.client_order_id();
2057
2058        let submit_params = Params::new(
2059            [(
2060                "routing_profile".to_string(),
2061                serde_json::Value::String("whole-size".to_string()),
2062            )]
2063            .into(),
2064        );
2065        algo.core
2066            .remember_submit_params(primary_id, Some(submit_params));
2067        algo.on_order(order).unwrap();
2068
2069        // Should submit entire size directly (no scheduling)
2070        assert!(algo.scheduled_orders.get(&primary_id).is_none());
2071        assert_eq!(algo.core.submit_params(&primary_id), None);
2072    }
2073
2074    #[rstest]
2075    fn test_twap_submits_entire_size_when_qty_per_interval_below_min_quantity() {
2076        use nautilus_model::instruments::{InstrumentAny, stubs::crypto_perpetual_ethusdt};
2077
2078        let mut algo = create_twap_algorithm();
2079        register_algorithm(&mut algo);
2080
2081        let mut instrument = crypto_perpetual_ethusdt();
2082        instrument.min_quantity = Some(Quantity::from("0.5"));
2083        {
2084            let cache_rc = algo.core.cache_rc();
2085            let mut cache = cache_rc.borrow_mut();
2086            cache
2087                .add_instrument(InstrumentAny::CryptoPerpetual(instrument))
2088                .unwrap();
2089        }
2090
2091        let mut params = IndexMap::new();
2092        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
2093        params.insert(Ustr::from("interval_secs"), Ustr::from("20"));
2094
2095        let order = create_market_order_with_params_and_qty(params, Quantity::from("1.2"));
2096        let primary_id = order.client_order_id();
2097
2098        let submit_params = Params::new(
2099            [(
2100                "routing_profile".to_string(),
2101                serde_json::Value::String("minimum-quantity".to_string()),
2102            )]
2103            .into(),
2104        );
2105        algo.core
2106            .remember_submit_params(primary_id, Some(submit_params));
2107
2108        algo.on_order(order).unwrap();
2109
2110        assert!(algo.scheduled_orders.get(&primary_id).is_none());
2111        assert_eq!(algo.core.submit_params(&primary_id), None);
2112    }
2113
2114    #[rstest]
2115    fn test_twap_rejects_negative_interval_secs() {
2116        let mut algo = create_twap_algorithm();
2117        register_algorithm(&mut algo);
2118
2119        add_instrument_to_cache(&algo);
2120
2121        let mut params = IndexMap::new();
2122        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
2123        params.insert(Ustr::from("interval_secs"), Ustr::from("-0.5"));
2124
2125        let order = create_market_order_with_params(params);
2126        assert_twap_denied(
2127            &mut algo,
2128            &order,
2129            "VALIDATION_FAILED: interval_secs=-0.5 must be finite and positive",
2130        );
2131    }
2132
2133    #[rstest]
2134    fn test_twap_rejects_negative_horizon_secs() {
2135        let mut algo = create_twap_algorithm();
2136        register_algorithm(&mut algo);
2137
2138        add_instrument_to_cache(&algo);
2139
2140        let mut params = IndexMap::new();
2141        params.insert(Ustr::from("horizon_secs"), Ustr::from("-10"));
2142        params.insert(Ustr::from("interval_secs"), Ustr::from("1"));
2143
2144        let order = create_market_order_with_params(params);
2145        assert_twap_denied(
2146            &mut algo,
2147            &order,
2148            "VALIDATION_FAILED: horizon_secs=-10 must be finite and positive",
2149        );
2150    }
2151
2152    #[rstest]
2153    fn test_twap_rejects_zero_interval_secs() {
2154        let mut algo = create_twap_algorithm();
2155        register_algorithm(&mut algo);
2156
2157        add_instrument_to_cache(&algo);
2158
2159        let mut params = IndexMap::new();
2160        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
2161        params.insert(Ustr::from("interval_secs"), Ustr::from("0"));
2162
2163        let order = create_market_order_with_params(params);
2164        assert_twap_denied(
2165            &mut algo,
2166            &order,
2167            "VALIDATION_FAILED: interval_secs=0 must be finite and positive",
2168        );
2169    }
2170
2171    #[rstest]
2172    fn test_twap_rejects_huge_finite_interval_before_submission() {
2173        let mut algo = create_twap_algorithm();
2174        register_algorithm(&mut algo);
2175
2176        add_instrument_to_cache(&algo);
2177
2178        let received = Rc::new(RefCell::new(None::<SubmitOrder>));
2179        let handler = msgbus::TypedIntoHandler::from({
2180            let captured = received.clone();
2181            move |cmd: TradingCommand| {
2182                if let TradingCommand::SubmitOrder(cmd) = cmd {
2183                    *captured.borrow_mut() = Some(cmd);
2184                }
2185            }
2186        });
2187        msgbus::register_trading_command_endpoint(
2188            MessagingSwitchboard::risk_engine_queue_execute(),
2189            handler,
2190        );
2191
2192        let mut params = IndexMap::new();
2193        params.insert(Ustr::from("horizon_secs"), Ustr::from("2e20"));
2194        params.insert(Ustr::from("interval_secs"), Ustr::from("1e20"));
2195
2196        let duration_error = Duration::try_from_secs_f64(1e20).unwrap_err();
2197        let reason = OrderDeniedReason::ValidationFailed {
2198            detail: format!(
2199                "interval_secs=100000000000000000000 is not a valid duration: {duration_error}"
2200            ),
2201        }
2202        .to_string();
2203        assert_twap_denied(&mut algo, &create_market_order_with_params(params), &reason);
2204
2205        assert!(received.borrow().is_none());
2206    }
2207
2208    #[rstest]
2209    fn test_twap_rejects_subnanosecond_interval_before_submission() {
2210        let mut algo = create_twap_algorithm();
2211        register_algorithm(&mut algo);
2212
2213        add_instrument_to_cache(&algo);
2214
2215        let received = Rc::new(RefCell::new(None::<SubmitOrder>));
2216        let handler = msgbus::TypedIntoHandler::from({
2217            let captured = received.clone();
2218            move |cmd: TradingCommand| {
2219                if let TradingCommand::SubmitOrder(cmd) = cmd {
2220                    *captured.borrow_mut() = Some(cmd);
2221                }
2222            }
2223        });
2224        msgbus::register_trading_command_endpoint(
2225            MessagingSwitchboard::risk_engine_queue_execute(),
2226            handler,
2227        );
2228
2229        let mut params = IndexMap::new();
2230        params.insert(Ustr::from("horizon_secs"), Ustr::from("2e-10"));
2231        params.insert(Ustr::from("interval_secs"), Ustr::from("1e-10"));
2232
2233        assert_twap_denied(
2234            &mut algo,
2235            &create_market_order_with_params(params),
2236            "VALIDATION_FAILED: interval_secs=0.0000000001 rounds to a zero duration",
2237        );
2238
2239        assert!(received.borrow().is_none());
2240    }
2241
2242    #[rstest]
2243    fn test_twap_rejects_interval_exceeding_timestamp_headroom_before_submission() {
2244        let mut algo = create_twap_algorithm();
2245        register_algorithm(&mut algo);
2246
2247        add_instrument_to_cache(&algo);
2248        DataActorNative::clock_mut(&mut algo)
2249            .as_any_mut()
2250            .downcast_mut::<VirtualClock>()
2251            .unwrap()
2252            .set_time(UnixNanos::new(u64::MAX - 500_000_000));
2253
2254        let received = Rc::new(RefCell::new(None::<SubmitOrder>));
2255        let handler = msgbus::TypedIntoHandler::from({
2256            let captured = received.clone();
2257            move |cmd: TradingCommand| {
2258                if let TradingCommand::SubmitOrder(cmd) = cmd {
2259                    *captured.borrow_mut() = Some(cmd);
2260                }
2261            }
2262        });
2263        msgbus::register_trading_command_endpoint(
2264            MessagingSwitchboard::risk_engine_queue_execute(),
2265            handler,
2266        );
2267
2268        let mut params = IndexMap::new();
2269        params.insert(Ustr::from("horizon_secs"), Ustr::from("2"));
2270        params.insert(Ustr::from("interval_secs"), Ustr::from("1"));
2271
2272        assert_twap_denied(
2273            &mut algo,
2274            &create_market_order_with_params(params),
2275            "VALIDATION_FAILED: interval_secs=1 exceeds the clock timestamp headroom",
2276        );
2277
2278        assert!(received.borrow().is_none());
2279    }
2280
2281    #[rstest]
2282    fn test_twap_rejects_nan_interval_secs() {
2283        let mut algo = create_twap_algorithm();
2284        register_algorithm(&mut algo);
2285
2286        add_instrument_to_cache(&algo);
2287
2288        let mut params = IndexMap::new();
2289        params.insert(Ustr::from("horizon_secs"), Ustr::from("60"));
2290        params.insert(Ustr::from("interval_secs"), Ustr::from("NaN"));
2291
2292        let order = create_market_order_with_params(params);
2293        assert_twap_denied(
2294            &mut algo,
2295            &order,
2296            "VALIDATION_FAILED: interval_secs=NaN must be finite and positive",
2297        );
2298    }
2299
2300    #[rstest]
2301    fn test_twap_rejects_infinity_horizon_secs() {
2302        let mut algo = create_twap_algorithm();
2303        register_algorithm(&mut algo);
2304
2305        add_instrument_to_cache(&algo);
2306
2307        let mut params = IndexMap::new();
2308        params.insert(Ustr::from("horizon_secs"), Ustr::from("inf"));
2309        params.insert(Ustr::from("interval_secs"), Ustr::from("10"));
2310
2311        let order = create_market_order_with_params(params);
2312        assert_twap_denied(
2313            &mut algo,
2314            &order,
2315            "VALIDATION_FAILED: horizon_secs=inf must be finite and positive",
2316        );
2317    }
2318}