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