1use 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
57pub type TwapAlgorithmConfig = ExecutionAlgorithmConfig;
59
60#[derive(Debug)]
66pub struct TwapAlgorithm {
67 pub core: ExecutionAlgorithmCore,
69 scheduled_orders: AHashMap<ClientOrderId, TwapSchedule>,
71}
72
73impl TwapAlgorithm {
74 #[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 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
96impl 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 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 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 {
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 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
452fn 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 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 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 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
589fn 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 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 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 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 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, false, false, false, None, None, None, None, None, None, None, None, None, None, None, 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, 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 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 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 {
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 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 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 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 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 assert_eq!(algo.scheduled_orders[&primary_id].remaining_sizes.len(), 2);
1804
1805 let event = TimeEvent::new(primary_id.inner(), UUID4::new(), 0.into(), 0.into());
1807 ExecutionAlgorithm::on_time_event(&mut algo, &event).unwrap();
1808
1809 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 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 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 let event = TimeEvent::new(primary_id.inner(), UUID4::new(), 0.into(), 0.into());
1886 ExecutionAlgorithm::on_time_event(&mut algo, &event).unwrap();
1887
1888 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 {
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 let event = TimeEvent::new(primary_id.inner(), UUID4::new(), 0.into(), 0.into());
1946 ExecutionAlgorithm::on_time_event(&mut algo, &event).unwrap();
1947
1948 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 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 assert!(
2010 algo.clock()
2011 .timer_names()
2012 .iter()
2013 .any(|name| name.as_str() == primary_id.as_str())
2014 );
2015
2016 DataActor::on_stop(&mut algo).unwrap();
2018
2019 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 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 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 algo.on_order(order).unwrap();
2343
2344 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 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 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 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 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 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 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}