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