1use std::{
19 sync::{
20 Arc,
21 atomic::{AtomicU64, Ordering},
22 },
23 time::Duration,
24};
25
26use ahash::AHashMap;
27use dashmap::DashMap;
28use nautilus_core::{UUID4, string::secret::SecretString, time::AtomicTime};
29use nautilus_live::task::TaskSpawner;
30use nautilus_model::{
31 events::{
32 OrderAccepted, OrderCancelRejected, OrderEventAny, OrderModifyRejected, OrderRejected,
33 OrderUpdated,
34 },
35 identifiers::{AccountId, ClientOrderId, TraderId, VenueOrderId},
36 types::{Price, Quantity},
37};
38use parking_lot::RwLock;
39use ustr::Ustr;
40
41use super::WsDispatchState;
42use crate::{
43 common::parse::{parse_venue_order_id, truncate_cl_ord_id},
44 websocket::spot_v2::{
45 enums::KrakenWsMethod,
46 handler::SpotHandlerCommand,
47 messages::{
48 KrakenWsAddOrderParams, KrakenWsAmendOrderParams, KrakenWsBatchAddParams,
49 KrakenWsCancelOrderParams, KrakenWsOrderResponse, KrakenWsOrderResult, KrakenWsParams,
50 KrakenWsRequest,
51 },
52 },
53};
54
55#[derive(Debug, Clone, Copy, PartialEq, Eq)]
56pub enum PendingOperation {
57 Submit,
59 Amend,
61 Cancel,
63 BatchAdd,
65}
66
67#[derive(Debug, Clone)]
68pub struct PendingRequest {
69 pub operation: PendingOperation,
71 pub client_order_ids: Vec<ClientOrderId>,
73 pub venue_order_ids: Vec<Option<VenueOrderId>>,
75 pub ts_sent_ns: u64,
77 pub new_quantity: Option<Quantity>,
82 pub new_price: Option<Price>,
86 pub new_trigger_price: Option<Price>,
90}
91
92#[derive(Debug)]
93pub struct OrderRequestState {
94 req_id_counter: Arc<AtomicU64>,
95 pending: DashMap<u64, PendingRequest>,
96 timeout: Duration,
97 cmd_tx_handle: Arc<tokio::sync::RwLock<tokio::sync::mpsc::UnboundedSender<SpotHandlerCommand>>>,
101 event_tx: tokio::sync::mpsc::UnboundedSender<OrderEventAny>,
102 dispatch_state: Arc<WsDispatchState>,
103 trader_id: TraderId,
104 account_id: AccountId,
105 auth_token: Arc<tokio::sync::RwLock<Option<SecretString>>>,
108 task_spawner: RwLock<TaskSpawner>,
109 clock: &'static AtomicTime,
111}
112
113impl OrderRequestState {
114 #[expect(clippy::too_many_arguments, reason = "all fields are independent")]
116 pub fn new(
117 cmd_tx_handle: Arc<
118 tokio::sync::RwLock<tokio::sync::mpsc::UnboundedSender<SpotHandlerCommand>>,
119 >,
120 event_tx: tokio::sync::mpsc::UnboundedSender<OrderEventAny>,
121 dispatch_state: Arc<WsDispatchState>,
122 req_id_counter: Arc<AtomicU64>,
123 timeout: Duration,
124 trader_id: TraderId,
125 account_id: AccountId,
126 auth_token: Arc<tokio::sync::RwLock<Option<SecretString>>>,
127 task_spawner: TaskSpawner,
128 clock: &'static AtomicTime,
129 ) -> Self {
130 Self {
131 req_id_counter,
132 pending: DashMap::new(),
133 timeout,
134 cmd_tx_handle,
135 event_tx,
136 dispatch_state,
137 trader_id,
138 account_id,
139 auth_token,
140 task_spawner: RwLock::new(task_spawner),
141 clock,
142 }
143 }
144
145 fn cmd_tx(&self) -> Option<tokio::sync::mpsc::UnboundedSender<SpotHandlerCommand>> {
148 self.cmd_tx_handle.try_read().ok().map(|g| g.clone())
149 }
150
151 pub fn next_req_id(&self) -> u64 {
153 self.req_id_counter.fetch_add(1, Ordering::Relaxed) + 1
154 }
155
156 pub fn submit(
163 self: &Arc<Self>,
164 params: KrakenWsAddOrderParams,
165 identity: PendingRequest,
166 ts_now_ns: u64,
167 ) -> anyhow::Result<u64> {
168 self.send(
169 KrakenWsRequest {
170 method: KrakenWsMethod::AddOrder,
171 params: Some(KrakenWsParams::AddOrder(params)),
172 req_id: None,
173 },
174 identity,
175 ts_now_ns,
176 )
177 }
178
179 pub fn amend(
185 self: &Arc<Self>,
186 params: KrakenWsAmendOrderParams,
187 identity: PendingRequest,
188 ts_now_ns: u64,
189 ) -> anyhow::Result<u64> {
190 self.send(
191 KrakenWsRequest {
192 method: KrakenWsMethod::AmendOrder,
193 params: Some(KrakenWsParams::AmendOrder(params)),
194 req_id: None,
195 },
196 identity,
197 ts_now_ns,
198 )
199 }
200
201 pub fn cancel(
207 self: &Arc<Self>,
208 params: KrakenWsCancelOrderParams,
209 identity: PendingRequest,
210 ts_now_ns: u64,
211 ) -> anyhow::Result<u64> {
212 self.send(
213 KrakenWsRequest {
214 method: KrakenWsMethod::CancelOrder,
215 params: Some(KrakenWsParams::CancelOrder(params)),
216 req_id: None,
217 },
218 identity,
219 ts_now_ns,
220 )
221 }
222
223 pub fn batch_add(
229 self: &Arc<Self>,
230 params: KrakenWsBatchAddParams,
231 identity: PendingRequest,
232 ts_now_ns: u64,
233 ) -> anyhow::Result<u64> {
234 self.send(
235 KrakenWsRequest {
236 method: KrakenWsMethod::BatchAdd,
237 params: Some(KrakenWsParams::BatchAdd(params)),
238 req_id: None,
239 },
240 identity,
241 ts_now_ns,
242 )
243 }
244
245 fn send(
246 self: &Arc<Self>,
247 mut envelope: KrakenWsRequest,
248 mut identity: PendingRequest,
249 ts_now_ns: u64,
250 ) -> anyhow::Result<u64> {
251 let req_id = self.next_req_id();
252 envelope.req_id = Some(req_id);
253 identity.ts_sent_ns = ts_now_ns;
254
255 let payload = SecretString::from(
256 serde_json::to_string(&envelope)
257 .map_err(|e| anyhow::anyhow!("serialize WS order request: {e}"))?,
258 );
259
260 let cmd_tx = self
261 .cmd_tx()
262 .ok_or_else(|| anyhow::anyhow!("WS handler command sender unavailable"))?;
263
264 self.pending.insert(req_id, identity);
265
266 if let Err(e) = cmd_tx.send(SpotHandlerCommand::SendOrderRequest { req_id, payload }) {
267 self.pending.remove(&req_id);
268 anyhow::bail!("handler command channel closed: {e}");
269 }
270
271 let state_for_timeout = Arc::downgrade(self);
272 let task_spawner = self.task_spawner.read().clone();
273 let cancel = task_spawner.cancellation_token();
274 let timeout = self.timeout;
275
276 if let Err(e) = task_spawner.spawn(async move {
277 tokio::select! {
278 biased;
279 () = cancel.cancelled() => {
280 if let Some(state) = state_for_timeout.upgrade() {
281 state.pending.remove(&req_id);
282 }
283 }
284 () = tokio::time::sleep(timeout) => {
285 let Some(state) = state_for_timeout.upgrade() else {
286 return;
287 };
288
289 if let Some(pending) = state.pending.get(&req_id) {
290 if cancel.is_cancelled() {
291 drop(pending);
292 state.pending.remove(&req_id);
293 return;
294 }
295
296 let ts_timeout_ns = state.clock.get_time_ns().as_u64();
297 log::warn!(
298 "Kraken WS response timeout req_id={req_id} op={:?} cl_ord_ids={:?} \
299 ts_timeout_ns={ts_timeout_ns}; awaiting definitive venue evidence",
300 pending.operation,
301 pending.client_order_ids,
302 );
303 state.handle_timeout(&pending);
304 }
305 }
306 }
307 }) {
308 log::warn!(
309 "Kraken order request {req_id} was sent without a local timeout task: {e}; \
310 awaiting definitive venue evidence"
311 );
312 }
313
314 Ok(req_id)
315 }
316
317 pub fn handle_response(&self, response: &KrakenWsOrderResponse, ts_event_ns: u64) {
323 let req_id = match response.req_id {
324 Some(id) => id,
325 None => {
326 log::warn!(
327 "Kraken WS order response without req_id method={:?} success={}",
328 response.method,
329 response.success,
330 );
331 return;
332 }
333 };
334
335 let Some(pending) = self.pending.get(&req_id) else {
336 log::debug!("Kraken WS response without pending request req_id={req_id}");
337 return;
338 };
339
340 let expected_method = pending_op_to_method(pending.operation);
341 if response.method != expected_method {
342 log::error!(
343 "Kraken WS response method {:?} mismatched pending op {:?} req_id={req_id}",
344 response.method,
345 pending.operation,
346 );
347 return;
348 }
349 drop(pending);
350
351 let Some((_, pending)) = self.pending.remove(&req_id) else {
352 log::debug!("Kraken WS duplicate response req_id={req_id}");
353 return;
354 };
355
356 match (pending.operation, response.success) {
357 (PendingOperation::Submit, true) => {
358 self.emit_order_accepted(&pending, response, ts_event_ns);
359 }
360 (PendingOperation::Submit, false) => {
361 self.emit_order_rejected(&pending, response, ts_event_ns);
362 }
363 (PendingOperation::Amend, true) => {
364 self.emit_order_updated(&pending, response, ts_event_ns);
365 }
366 (PendingOperation::Amend, false) => {
367 self.emit_order_modify_rejected(&pending, response, ts_event_ns);
368 }
369 (PendingOperation::Cancel, true) => {
370 log::debug!(
371 "Kraken WS cancel ack req_id={req_id} cl_ord_ids={:?}",
372 pending.client_order_ids,
373 );
374 }
375 (PendingOperation::Cancel, false) => {
376 self.emit_order_cancel_rejected(&pending, response, ts_event_ns);
377 }
378 (PendingOperation::BatchAdd, _) => {
379 self.handle_batch_add_response(&pending, response, ts_event_ns);
380 }
381 }
382 }
383
384 fn handle_timeout(&self, pending: &PendingRequest) {
385 match pending.operation {
386 PendingOperation::Submit => {
387 self.send_compensating_cancel(&pending.client_order_ids);
388 }
389 PendingOperation::Amend | PendingOperation::Cancel => {}
390 PendingOperation::BatchAdd => {
391 self.send_compensating_cancel(&pending.client_order_ids);
392 }
393 }
394 }
395
396 pub(crate) fn clear(&self) {
397 self.pending.clear();
398 }
399
400 pub(crate) fn reset_task_spawner(&self, task_spawner: TaskSpawner) {
401 *self.task_spawner.write() = task_spawner;
402 }
403
404 fn send_compensating_cancel(&self, cl_ord_ids: &[ClientOrderId]) {
415 let Some(token) = self
416 .auth_token
417 .try_read()
418 .ok()
419 .and_then(|guard| guard.clone())
420 else {
421 log::warn!(
422 "Submit timeout: no auth token for compensating cancel cl_ord_ids={cl_ord_ids:?}; \
423 relying on reconciliation to recover any orphan order",
424 );
425 return;
426 };
427
428 let req_id = self.next_req_id();
429 let params = KrakenWsCancelOrderParams {
430 token,
431 order_id: None,
432 cl_ord_id: Some(cl_ord_ids.iter().map(truncate_cl_ord_id).collect()),
433 };
434 let envelope = KrakenWsRequest {
435 method: KrakenWsMethod::CancelOrder,
436 params: Some(KrakenWsParams::CancelOrder(params)),
437 req_id: Some(req_id),
438 };
439
440 let payload = match serde_json::to_string(&envelope) {
441 Ok(payload) => SecretString::from(payload),
442 Err(e) => {
443 log::warn!("Submit timeout: compensating cancel serialize failed: {e}");
444 return;
445 }
446 };
447
448 let Some(cmd_tx) = self.cmd_tx() else {
449 log::warn!(
450 "Submit timeout: compensating cancel sender unavailable cl_ord_ids={cl_ord_ids:?}; \
451 relying on reconciliation to recover any orphan order",
452 );
453 return;
454 };
455
456 if let Err(e) = cmd_tx.send(SpotHandlerCommand::SendOrderRequest { req_id, payload }) {
457 log::warn!(
458 "Submit timeout: compensating cancel channel closed: {e}; \
459 relying on reconciliation to recover any orphan order",
460 );
461 } else {
462 log::debug!(
463 "Submit timeout: compensating cancel sent req_id={req_id} cl_ord_ids={cl_ord_ids:?}",
464 );
465 }
466 }
467
468 fn emit_order_accepted(
469 &self,
470 pending: &PendingRequest,
471 response: &KrakenWsOrderResponse,
472 ts_event_ns: u64,
473 ) {
474 let Some(client_order_id) = pending.client_order_ids.first().copied() else {
475 log::error!("Kraken WS add_order response without client_order_id");
476 return;
477 };
478 let Some(identity) = self.dispatch_state.lookup_identity(&client_order_id) else {
479 log::warn!(
480 "Kraken WS add_order response for untracked order client_order_id={client_order_id}",
481 );
482 return;
483 };
484 let Ok(venue_order_id) = response
485 .result
486 .as_ref()
487 .and_then(|r| r.order_id.as_deref())
488 .map(|id| {
489 parse_venue_order_id(
490 id,
491 format_args!("WS add_order response for {client_order_id}"),
492 )
493 })
494 .transpose()
495 .inspect_err(|e| log::error!("{e}"))
496 else {
497 return;
498 };
499 let Some(venue_order_id) = venue_order_id else {
500 log::error!(
501 "Kraken WS add_order success without order_id client_order_id={client_order_id}",
502 );
503 return;
504 };
505
506 if !self.dispatch_state.insert_accepted(client_order_id) {
507 return;
508 }
509
510 let event = OrderAccepted::new(
511 self.trader_id,
512 identity.strategy_id,
513 identity.instrument_id,
514 client_order_id,
515 venue_order_id,
516 self.account_id,
517 UUID4::new(),
518 ts_event_ns.into(),
519 ts_event_ns.into(),
520 false,
521 );
522 self.send_event(OrderEventAny::Accepted(event));
523 }
524
525 fn emit_order_rejected(
526 &self,
527 pending: &PendingRequest,
528 response: &KrakenWsOrderResponse,
529 ts_event_ns: u64,
530 ) {
531 let Some(client_order_id) = pending.client_order_ids.first().copied() else {
532 log::error!("Kraken WS add_order rejection without client_order_id");
533 return;
534 };
535 let Some(identity) = self.dispatch_state.lookup_identity(&client_order_id) else {
536 log::warn!(
537 "Kraken WS add_order rejection for untracked order client_order_id={client_order_id}",
538 );
539 return;
540 };
541 let reason = response
542 .error
543 .as_deref()
544 .filter(|s| !s.is_empty())
545 .unwrap_or("UNKNOWN");
546
547 let event = OrderRejected::new(
548 self.trader_id,
549 identity.strategy_id,
550 identity.instrument_id,
551 client_order_id,
552 self.account_id,
553 Ustr::from(reason),
554 UUID4::new(),
555 ts_event_ns.into(),
556 ts_event_ns.into(),
557 false,
558 false,
559 );
560 self.send_event(OrderEventAny::Rejected(event));
561 }
562
563 fn emit_order_updated(
564 &self,
565 pending: &PendingRequest,
566 response: &KrakenWsOrderResponse,
567 ts_event_ns: u64,
568 ) {
569 let Some(client_order_id) = pending.client_order_ids.first().copied() else {
570 log::error!("Kraken WS amend_order response without client_order_id");
571 return;
572 };
573 let Some(identity) = self.dispatch_state.lookup_identity(&client_order_id) else {
574 log::warn!(
575 "Kraken WS amend_order response for untracked order client_order_id={client_order_id}",
576 );
577 return;
578 };
579 let Ok(venue_order_id) = response
582 .result
583 .as_ref()
584 .and_then(|r| r.order_id.as_deref())
585 .map(|id| {
586 parse_venue_order_id(
587 id,
588 format_args!("WS amend_order response for {client_order_id}"),
589 )
590 })
591 .transpose()
592 .inspect_err(|e| log::error!("{e}"))
593 else {
594 return;
595 };
596 let venue_order_id =
597 venue_order_id.or_else(|| pending.venue_order_ids.first().copied().flatten());
598
599 let quantity = pending.new_quantity.unwrap_or(identity.quantity);
600 if pending.new_quantity.is_some() {
601 self.dispatch_state
602 .update_identity_quantity(&client_order_id, quantity);
603 }
604
605 let event = OrderUpdated::new(
606 self.trader_id,
607 identity.strategy_id,
608 identity.instrument_id,
609 client_order_id,
610 quantity,
611 UUID4::new(),
612 ts_event_ns.into(),
613 ts_event_ns.into(),
614 false,
615 venue_order_id,
616 Some(self.account_id),
617 pending.new_price,
618 pending.new_trigger_price,
619 None,
620 false,
621 );
622 self.send_event(OrderEventAny::Updated(event));
623 }
624
625 fn emit_order_modify_rejected(
626 &self,
627 pending: &PendingRequest,
628 response: &KrakenWsOrderResponse,
629 ts_event_ns: u64,
630 ) {
631 let Some(client_order_id) = pending.client_order_ids.first().copied() else {
632 log::error!("Kraken WS amend_order rejection without client_order_id");
633 return;
634 };
635 let Some(identity) = self.dispatch_state.lookup_identity(&client_order_id) else {
636 log::debug!(
637 "Kraken WS amend_order rejection for untracked order client_order_id={client_order_id}",
638 );
639 return;
640 };
641 let venue_order_id = pending.venue_order_ids.first().copied().flatten();
642 let reason = response
643 .error
644 .as_deref()
645 .filter(|s| !s.is_empty())
646 .unwrap_or("UNKNOWN");
647
648 let event = OrderModifyRejected::new(
649 self.trader_id,
650 identity.strategy_id,
651 identity.instrument_id,
652 client_order_id,
653 Ustr::from(reason),
654 UUID4::new(),
655 ts_event_ns.into(),
656 ts_event_ns.into(),
657 false,
658 venue_order_id,
659 Some(self.account_id),
660 );
661 self.send_event(OrderEventAny::ModifyRejected(event));
662 }
663
664 fn emit_order_cancel_rejected(
665 &self,
666 pending: &PendingRequest,
667 response: &KrakenWsOrderResponse,
668 ts_event_ns: u64,
669 ) {
670 let Some(client_order_id) = pending.client_order_ids.first().copied() else {
671 log::error!("Kraken WS cancel_order rejection without client_order_id");
672 return;
673 };
674 let Some(identity) = self.dispatch_state.lookup_identity(&client_order_id) else {
675 log::debug!(
676 "Kraken WS cancel_order rejection for untracked order client_order_id={client_order_id}",
677 );
678 return;
679 };
680 let venue_order_id = pending.venue_order_ids.first().copied().flatten();
681 let reason = response
682 .error
683 .as_deref()
684 .filter(|s| !s.is_empty())
685 .unwrap_or("UNKNOWN");
686
687 let event = OrderCancelRejected::new(
688 self.trader_id,
689 identity.strategy_id,
690 identity.instrument_id,
691 client_order_id,
692 Ustr::from(reason),
693 UUID4::new(),
694 ts_event_ns.into(),
695 ts_event_ns.into(),
696 false,
697 venue_order_id,
698 Some(self.account_id),
699 );
700 self.send_event(OrderEventAny::CancelRejected(event));
701 }
702
703 fn handle_batch_add_response(
704 &self,
705 pending: &PendingRequest,
706 response: &KrakenWsOrderResponse,
707 ts_event_ns: u64,
708 ) {
709 let per_order = response
710 .result
711 .as_ref()
712 .and_then(|r| r.orders.as_ref())
713 .map_or(&[][..], Vec::as_slice);
714
715 let echo_index: AHashMap<&str, usize> = per_order
721 .iter()
722 .enumerate()
723 .filter_map(|(i, r)| r.cl_ord_id.as_deref().map(|cid| (cid, i)))
724 .collect();
725
726 for (idx, client_order_id) in pending.client_order_ids.iter().copied().enumerate() {
727 let leg_venue = pending.venue_order_ids.get(idx).copied().flatten();
728 let truncated = truncate_cl_ord_id(&client_order_id);
729 let leg_result = echo_index
730 .get(truncated.as_str())
731 .and_then(|&i| per_order.get(i))
732 .or_else(|| per_order.get(idx));
733
734 if leg_result.is_none() {
735 log::error!(
736 "Kraken WS batch_add response missing per-leg result for client_order_id={client_order_id} idx={idx} \
737 legs_sent={legs_sent} legs_received={legs_received}; treating as rejection",
738 legs_sent = pending.client_order_ids.len(),
739 legs_received = per_order.len(),
740 );
741 }
742
743 let leg_success = leg_result.is_some_and(|r| r.success);
744 let leg_order_id = leg_result
745 .and_then(|r| r.order_id.clone())
746 .or_else(|| leg_venue.map(|v| v.to_string()));
747 let leg_error = leg_result.and_then(|r| r.error.clone()).or_else(|| {
748 if leg_result.is_none() {
749 Some(format!(
750 "batch_add response missing per-leg result (legs_sent={}, legs_received={})",
751 pending.client_order_ids.len(),
752 per_order.len(),
753 ))
754 } else {
755 response.error.clone()
756 }
757 });
758
759 let leg_response = KrakenWsOrderResponse {
760 method: KrakenWsMethod::AddOrder,
761 req_id: response.req_id,
762 success: leg_success,
763 time_in: response.time_in.clone(),
764 time_out: response.time_out.clone(),
765 error: leg_error,
766 result: leg_order_id.map(|order_id| KrakenWsOrderResult {
767 order_id: Some(order_id),
768 cl_ord_id: leg_result.and_then(|r| r.cl_ord_id.clone()),
769 order_userref: None,
770 warning: None,
771 orders: None,
772 }),
773 };
774 let leg_pending = PendingRequest {
775 operation: PendingOperation::Submit,
776 client_order_ids: vec![client_order_id],
777 venue_order_ids: vec![leg_venue],
778 ts_sent_ns: pending.ts_sent_ns,
779 new_quantity: None,
780 new_price: None,
781 new_trigger_price: None,
782 };
783
784 if leg_success {
785 self.emit_order_accepted(&leg_pending, &leg_response, ts_event_ns);
786 } else {
787 self.emit_order_rejected(&leg_pending, &leg_response, ts_event_ns);
788 }
789 }
790 }
791
792 fn send_event(&self, event: OrderEventAny) {
801 if let Err(e) = self.event_tx.send(event) {
802 log::error!("Kraken WS order-event channel send failed: {e}");
803 }
804 }
805}
806
807fn pending_op_to_method(op: PendingOperation) -> KrakenWsMethod {
808 match op {
809 PendingOperation::Submit => KrakenWsMethod::AddOrder,
810 PendingOperation::Amend => KrakenWsMethod::AmendOrder,
811 PendingOperation::Cancel => KrakenWsMethod::CancelOrder,
812 PendingOperation::BatchAdd => KrakenWsMethod::BatchAdd,
813 }
814}
815
816#[cfg(test)]
817impl OrderRequestState {
818 pub(crate) fn pending_len(&self) -> usize {
819 self.pending.len()
820 }
821}
822
823#[cfg(test)]
824mod tests {
825 use std::sync::atomic::AtomicU64;
826
827 use nautilus_core::string::secret::REDACTED;
828 use nautilus_live::task::TaskGroup;
829 use nautilus_model::{
830 enums::{OrderSide, OrderType},
831 identifiers::{AccountId, ClientOrderId, InstrumentId, StrategyId, TraderId},
832 types::{Price, Quantity},
833 };
834 use rstest::rstest;
835 use rust_decimal_macros::dec;
836
837 use super::*;
838 use crate::{
839 common::enums::{KrakenOrderSide, KrakenOrderType},
840 websocket::{
841 dispatch::OrderIdentity,
842 spot_v2::messages::{
843 KrakenWsAddOrderParams, KrakenWsAmendOrderParams, KrakenWsBatchAddParams,
844 KrakenWsBatchOrderResult, KrakenWsCancelOrderParams, KrakenWsOrderResponse,
845 KrakenWsOrderResult,
846 },
847 },
848 };
849
850 const CLIENT_ORDER_ID: &str = "O-1";
851 const VENUE_ORDER_ID: &str = "O-VENUE";
852 const INSTRUMENT_ID: &str = "BTCUSD.KRAKEN";
853
854 pub(super) struct Harness {
855 pub(super) state: Arc<OrderRequestState>,
856 pub(super) cmd_rx: tokio::sync::mpsc::UnboundedReceiver<SpotHandlerCommand>,
857 pub(super) event_rx: tokio::sync::mpsc::UnboundedReceiver<OrderEventAny>,
858 pub(super) dispatch_state: Arc<WsDispatchState>,
859 pub(super) auth_token: Arc<tokio::sync::RwLock<Option<SecretString>>>,
860 pub(super) pending_tasks: TaskGroup,
861 pub(super) cmd_tx_handle:
862 Arc<tokio::sync::RwLock<tokio::sync::mpsc::UnboundedSender<SpotHandlerCommand>>>,
863 }
864
865 pub(super) fn make_harness(timeout_ms: u64) -> Harness {
866 let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
867 let (event_tx, event_rx) = tokio::sync::mpsc::unbounded_channel();
868 let counter = Arc::new(AtomicU64::new(0));
869 let dispatch_state = Arc::new(WsDispatchState::new());
870 let auth_token = Arc::new(tokio::sync::RwLock::new(None));
871 let pending_tasks = TaskGroup::new();
872 let pending_spawner = pending_tasks.spawner().expect("pending task spawner");
873 let cmd_tx_handle = Arc::new(tokio::sync::RwLock::new(cmd_tx));
874 let state = Arc::new(OrderRequestState::new(
875 Arc::clone(&cmd_tx_handle),
876 event_tx,
877 Arc::clone(&dispatch_state),
878 counter,
879 Duration::from_millis(timeout_ms),
880 TraderId::new("TESTER-001"),
881 AccountId::new("KRAKEN-001"),
882 Arc::clone(&auth_token),
883 pending_spawner,
884 nautilus_core::time::get_atomic_clock_realtime(),
885 ));
886 Harness {
887 state,
888 cmd_rx,
889 event_rx,
890 dispatch_state,
891 auth_token,
892 pending_tasks,
893 cmd_tx_handle,
894 }
895 }
896
897 #[rstest]
898 #[tokio::test]
899 async fn debug_redacts_auth_token() {
900 let harness = make_harness(100);
901 *harness.auth_token.write().await =
902 Some(SecretString::from("kraken-auth-token".to_string()));
903
904 let debug = format!("{:?}", harness.state);
905
906 assert!(debug.contains(REDACTED));
907 assert!(!debug.contains("kraken-auth-token"));
908 }
909
910 fn register_default_identity(dispatch_state: &WsDispatchState, cl_ord_id: ClientOrderId) {
911 dispatch_state.register_identity(
912 cl_ord_id,
913 OrderIdentity {
914 strategy_id: StrategyId::new("S-1"),
915 instrument_id: InstrumentId::from(INSTRUMENT_ID),
916 order_side: OrderSide::Buy,
917 order_type: OrderType::Limit,
918 quantity: Quantity::from("0.001"),
919 },
920 );
921 }
922
923 fn make_state(
924 timeout_ms: u64,
925 ) -> (
926 Arc<OrderRequestState>,
927 tokio::sync::mpsc::UnboundedReceiver<SpotHandlerCommand>,
928 ) {
929 let harness = make_harness(timeout_ms);
930 (harness.state, harness.cmd_rx)
931 }
932
933 fn make_identity(op: PendingOperation) -> PendingRequest {
934 PendingRequest {
935 operation: op,
936 client_order_ids: vec![ClientOrderId::from(CLIENT_ORDER_ID)],
937 venue_order_ids: vec![None],
938 ts_sent_ns: 0,
939 new_quantity: None,
940 new_price: None,
941 new_trigger_price: None,
942 }
943 }
944
945 fn make_add_order_params(token: &str) -> KrakenWsAddOrderParams {
946 KrakenWsAddOrderParams {
947 order_type: KrakenOrderType::Limit,
948 side: KrakenOrderSide::Buy,
949 order_qty: dec!(0.001),
950 symbol: "BTC/USD".to_string(),
951 token: SecretString::from(token),
952 limit_price: Some(dec!(50000)),
953 time_in_force: None,
954 expire_time: None,
955 cl_ord_id: Some(CLIENT_ORDER_ID.to_string()),
956 post_only: None,
957 reduce_only: None,
958 leverage: None,
959 trigger: None,
960 conditional: None,
961 }
962 }
963
964 #[rstest]
965 fn test_next_req_id_is_monotonic() {
966 let (state, _rx) = make_state(1_000);
967 let a = state.next_req_id();
968 let b = state.next_req_id();
969 let c = state.next_req_id();
970 assert!(b > a && c > b);
971 }
972
973 #[rstest]
974 fn test_submit_registers_pending_and_sends_command() {
975 let (state, mut rx) = make_state(60_000);
976 let identity = make_identity(PendingOperation::Submit);
977
978 let params = KrakenWsAddOrderParams {
979 order_type: KrakenOrderType::Limit,
980 side: KrakenOrderSide::Buy,
981 order_qty: dec!(0.001),
982 symbol: "BTC/USD".to_string(),
983 token: SecretString::from("test-token"),
984 limit_price: Some(dec!(50000)),
985 time_in_force: None,
986 expire_time: None,
987 cl_ord_id: Some("O-1".to_string()),
988 post_only: None,
989 reduce_only: None,
990 leverage: None,
991 trigger: None,
992 conditional: None,
993 };
994
995 let req_id = state.submit(params, identity, 1).expect("submit ok");
996 assert_eq!(state.pending_len(), 1);
997
998 let cmd = rx.try_recv().expect("cmd queued");
999 match cmd {
1000 SpotHandlerCommand::SendOrderRequest {
1001 req_id: rid,
1002 payload,
1003 } => {
1004 assert_eq!(rid, req_id);
1005 assert!(payload.expose_secret().contains("\"add_order\""));
1006 assert!(
1007 payload
1008 .expose_secret()
1009 .contains(&format!("\"req_id\":{req_id}")),
1010 );
1011 }
1012 _ => panic!("wrong cmd variant"),
1013 }
1014 }
1015
1016 #[tokio::test]
1017 async fn test_submit_uses_swapped_command_sender() {
1018 let harness = make_harness(60_000);
1021
1022 drop(harness.cmd_rx);
1023 let (new_cmd_tx, mut new_cmd_rx) = tokio::sync::mpsc::unbounded_channel();
1024 *harness.cmd_tx_handle.write().await = new_cmd_tx;
1025
1026 let params = KrakenWsAddOrderParams {
1027 order_type: KrakenOrderType::Limit,
1028 side: KrakenOrderSide::Buy,
1029 order_qty: dec!(0.001),
1030 symbol: "BTC/USD".to_string(),
1031 token: SecretString::from("TKN"),
1032 limit_price: Some(dec!(50000)),
1033 time_in_force: None,
1034 expire_time: None,
1035 cl_ord_id: Some(CLIENT_ORDER_ID.to_string()),
1036 post_only: None,
1037 reduce_only: None,
1038 leverage: None,
1039 trigger: None,
1040 conditional: None,
1041 };
1042 let identity = make_identity(PendingOperation::Submit);
1043
1044 harness
1045 .state
1046 .submit(params, identity, 1)
1047 .expect("submit must succeed via the swapped sender");
1048
1049 let cmd = new_cmd_rx
1050 .try_recv()
1051 .expect("swapped receiver must observe the order");
1052
1053 match cmd {
1054 SpotHandlerCommand::SendOrderRequest { payload, .. } => {
1055 assert!(payload.expose_secret().contains("\"add_order\""));
1056 }
1057 other => panic!("expected SendOrderRequest, was {other:?}"),
1058 }
1059 }
1060
1061 #[rstest]
1062 fn test_amend_sends_amend_order_envelope() {
1063 let (state, mut rx) = make_state(60_000);
1064 let params = KrakenWsAmendOrderParams {
1065 order_id: Some("O-VENUE".to_string()),
1066 cl_ord_id: None,
1067 order_qty: Some(dec!(0.005)),
1068 limit_price: None,
1069 trigger_price: None,
1070 token: SecretString::from("TKN"),
1071 };
1072 let identity = PendingRequest {
1073 operation: PendingOperation::Amend,
1074 client_order_ids: vec![ClientOrderId::from("O-1")],
1075 venue_order_ids: vec![Some(VenueOrderId::from("O-VENUE"))],
1076 ts_sent_ns: 0,
1077 new_quantity: None,
1078 new_price: None,
1079 new_trigger_price: None,
1080 };
1081 let _ = state.amend(params, identity, 1).expect("amend ok");
1082 let cmd = rx.try_recv().unwrap();
1083 if let SpotHandlerCommand::SendOrderRequest { payload, .. } = cmd {
1084 assert!(payload.expose_secret().contains("\"amend_order\""));
1085 } else {
1086 panic!("wrong variant");
1087 }
1088 }
1089
1090 #[rstest]
1091 fn test_cancel_sends_cancel_order_envelope() {
1092 let (state, mut rx) = make_state(60_000);
1093 let params = KrakenWsCancelOrderParams {
1094 order_id: Some(vec!["O-VENUE".to_string()]),
1095 cl_ord_id: None,
1096 token: SecretString::from("TKN"),
1097 };
1098 let identity = PendingRequest {
1099 operation: PendingOperation::Cancel,
1100 client_order_ids: vec![ClientOrderId::from("O-1")],
1101 venue_order_ids: vec![Some(VenueOrderId::from("O-VENUE"))],
1102 ts_sent_ns: 0,
1103 new_quantity: None,
1104 new_price: None,
1105 new_trigger_price: None,
1106 };
1107 let _ = state.cancel(params, identity, 1).expect("cancel ok");
1108 let cmd = rx.try_recv().unwrap();
1109 if let SpotHandlerCommand::SendOrderRequest { payload, .. } = cmd {
1110 assert!(payload.expose_secret().contains("\"cancel_order\""));
1111 } else {
1112 panic!("wrong variant");
1113 }
1114 }
1115
1116 #[rstest]
1117 fn test_batch_add_sends_batch_add_envelope() {
1118 let (state, mut rx) = make_state(60_000);
1119 let params = KrakenWsBatchAddParams {
1120 symbol: "BTC/USD".to_string(),
1121 orders: vec![],
1122 token: SecretString::from("TKN"),
1123 };
1124 let identity = PendingRequest {
1125 operation: PendingOperation::BatchAdd,
1126 client_order_ids: vec![ClientOrderId::from("O-A"), ClientOrderId::from("O-B")],
1127 venue_order_ids: vec![None, None],
1128 ts_sent_ns: 0,
1129 new_quantity: None,
1130 new_price: None,
1131 new_trigger_price: None,
1132 };
1133 let _ = state.batch_add(params, identity, 1).expect("batch ok");
1134 let cmd = rx.try_recv().unwrap();
1135 if let SpotHandlerCommand::SendOrderRequest { payload, .. } = cmd {
1136 assert!(payload.expose_secret().contains("\"batch_add\""));
1137 } else {
1138 panic!("wrong variant");
1139 }
1140 }
1141
1142 fn make_response(
1143 method: KrakenWsMethod,
1144 success: bool,
1145 req_id: u64,
1146 order_id: Option<&str>,
1147 error: Option<&str>,
1148 ) -> KrakenWsOrderResponse {
1149 KrakenWsOrderResponse {
1150 method,
1151 req_id: Some(req_id),
1152 success,
1153 time_in: None,
1154 time_out: None,
1155 error: error.map(str::to_string),
1156 result: order_id.map(|id| KrakenWsOrderResult {
1157 order_id: Some(id.to_string()),
1158 cl_ord_id: None,
1159 order_userref: None,
1160 warning: None,
1161 orders: None,
1162 }),
1163 }
1164 }
1165
1166 #[rstest]
1167 fn test_handle_response_submit_success_emits_order_accepted() {
1168 let mut harness = make_harness(60_000);
1169 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1170 register_default_identity(&harness.dispatch_state, cl_ord_id);
1171
1172 let req_id = 42;
1173 harness
1174 .state
1175 .pending
1176 .insert(req_id, make_identity(PendingOperation::Submit));
1177
1178 let response = make_response(
1179 KrakenWsMethod::AddOrder,
1180 true,
1181 req_id,
1182 Some(VENUE_ORDER_ID),
1183 None,
1184 );
1185 harness.state.handle_response(&response, 1_000);
1186
1187 assert_eq!(harness.state.pending_len(), 0);
1188 let event = harness.event_rx.try_recv().expect("event emitted");
1189 match event {
1190 OrderEventAny::Accepted(e) => {
1191 assert_eq!(e.client_order_id, cl_ord_id);
1192 assert_eq!(e.venue_order_id.as_str(), VENUE_ORDER_ID);
1193 assert_eq!(e.account_id.as_str(), "KRAKEN-001");
1194 }
1195 other => panic!("expected Accepted, was {other:?}"),
1196 }
1197 }
1198
1199 #[rstest]
1202 fn test_handle_response_submit_with_an_invalid_order_id_emits_nothing() {
1203 let mut harness = make_harness(60_000);
1204 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1205 register_default_identity(&harness.dispatch_state, cl_ord_id);
1206
1207 let req_id = 43;
1208 harness
1209 .state
1210 .pending
1211 .insert(req_id, make_identity(PendingOperation::Submit));
1212
1213 let response = make_response(KrakenWsMethod::AddOrder, true, req_id, Some(""), None);
1214 harness.state.handle_response(&response, 1_000);
1215
1216 assert_eq!(harness.state.pending_len(), 0);
1217 assert!(harness.event_rx.try_recv().is_err());
1218 assert!(harness.dispatch_state.lookup_identity(&cl_ord_id).is_some());
1219 }
1220
1221 #[rstest]
1224 fn test_handle_response_amend_with_an_invalid_order_id_emits_nothing() {
1225 let mut harness = make_harness(60_000);
1226 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1227 register_default_identity(&harness.dispatch_state, cl_ord_id);
1228
1229 let req_id = 44;
1230 harness.state.pending.insert(
1231 req_id,
1232 PendingRequest {
1233 operation: PendingOperation::Amend,
1234 client_order_ids: vec![cl_ord_id],
1235 venue_order_ids: vec![Some(VenueOrderId::from(VENUE_ORDER_ID))],
1236 ts_sent_ns: 0,
1237 new_quantity: Some(Quantity::from("0.005")),
1238 new_price: None,
1239 new_trigger_price: None,
1240 },
1241 );
1242
1243 let response = make_response(KrakenWsMethod::AmendOrder, true, req_id, Some(""), None);
1244 harness.state.handle_response(&response, 3_000);
1245
1246 assert!(harness.event_rx.try_recv().is_err());
1247 assert_eq!(
1248 harness
1249 .dispatch_state
1250 .lookup_identity(&cl_ord_id)
1251 .unwrap()
1252 .quantity,
1253 Quantity::from("0.001")
1254 );
1255 }
1256
1257 #[rstest]
1259 fn test_handle_response_amend_without_an_order_id_uses_the_pending_id() {
1260 let mut harness = make_harness(60_000);
1261 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1262 register_default_identity(&harness.dispatch_state, cl_ord_id);
1263
1264 let req_id = 45;
1265 harness.state.pending.insert(
1266 req_id,
1267 PendingRequest {
1268 operation: PendingOperation::Amend,
1269 client_order_ids: vec![cl_ord_id],
1270 venue_order_ids: vec![Some(VenueOrderId::from(VENUE_ORDER_ID))],
1271 ts_sent_ns: 0,
1272 new_quantity: None,
1273 new_price: None,
1274 new_trigger_price: None,
1275 },
1276 );
1277
1278 let response = make_response(KrakenWsMethod::AmendOrder, true, req_id, None, None);
1279 harness.state.handle_response(&response, 3_000);
1280
1281 match harness.event_rx.try_recv().expect("event emitted") {
1282 OrderEventAny::Updated(e) => {
1283 assert_eq!(
1284 e.venue_order_id.expect("venue id present").as_str(),
1285 VENUE_ORDER_ID
1286 );
1287 }
1288 other => panic!("expected Updated, was {other:?}"),
1289 }
1290 }
1291
1292 #[rstest]
1295 fn test_handle_response_batch_add_resolves_each_leg_of_an_invalid_order_id() {
1296 let mut harness = make_harness(60_000);
1297 let cl_a = ClientOrderId::from("O-A");
1298 let cl_b = ClientOrderId::from("O-B");
1299 let cl_c = ClientOrderId::from("O-C");
1300 register_default_identity(&harness.dispatch_state, cl_a);
1301 register_default_identity(&harness.dispatch_state, cl_b);
1302 register_default_identity(&harness.dispatch_state, cl_c);
1303
1304 let req_id = 51;
1305 harness.state.pending.insert(
1306 req_id,
1307 PendingRequest {
1308 operation: PendingOperation::BatchAdd,
1309 client_order_ids: vec![cl_a, cl_b, cl_c],
1310 venue_order_ids: vec![None, None, None],
1311 ts_sent_ns: 0,
1312 new_quantity: None,
1313 new_price: None,
1314 new_trigger_price: None,
1315 },
1316 );
1317
1318 let response = KrakenWsOrderResponse {
1319 method: KrakenWsMethod::BatchAdd,
1320 req_id: Some(req_id),
1321 success: true,
1322 time_in: None,
1323 time_out: None,
1324 error: None,
1325 result: Some(KrakenWsOrderResult {
1326 order_id: None,
1327 cl_ord_id: None,
1328 order_userref: None,
1329 warning: None,
1330 orders: Some(vec![
1331 KrakenWsBatchOrderResult {
1332 success: true,
1333 order_id: Some(String::new()),
1334 cl_ord_id: Some("O-A".to_string()),
1335 error: None,
1336 },
1337 KrakenWsBatchOrderResult {
1338 success: false,
1339 order_id: Some(String::new()),
1340 cl_ord_id: Some("O-B".to_string()),
1341 error: Some("Bad price".to_string()),
1342 },
1343 KrakenWsBatchOrderResult {
1344 success: true,
1345 order_id: Some("V-C".to_string()),
1346 cl_ord_id: Some("O-C".to_string()),
1347 error: None,
1348 },
1349 ]),
1350 }),
1351 };
1352 harness.state.handle_response(&response, 9_000);
1353
1354 match harness.event_rx.try_recv().expect("the failed leg rejects") {
1355 OrderEventAny::Rejected(e) => {
1356 assert_eq!(e.client_order_id, cl_b);
1357 assert_eq!(e.reason, Ustr::from("Bad price"));
1358 }
1359 other => panic!("expected Rejected, was {other:?}"),
1360 }
1361
1362 match harness.event_rx.try_recv().expect("the valid leg accepts") {
1363 OrderEventAny::Accepted(e) => {
1364 assert_eq!(e.client_order_id, cl_c);
1365 assert_eq!(e.venue_order_id, VenueOrderId::from("V-C"));
1366 }
1367 other => panic!("expected Accepted, was {other:?}"),
1368 }
1369 assert!(harness.event_rx.try_recv().is_err());
1370 assert!(harness.dispatch_state.lookup_identity(&cl_a).is_some());
1371 assert!(!harness.dispatch_state.emitted_accepted.contains(&cl_a));
1372 }
1373
1374 #[rstest]
1375 fn test_handle_response_submit_failure_emits_order_rejected() {
1376 let mut harness = make_harness(60_000);
1377 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1378 register_default_identity(&harness.dispatch_state, cl_ord_id);
1379
1380 let req_id = 7;
1381 harness
1382 .state
1383 .pending
1384 .insert(req_id, make_identity(PendingOperation::Submit));
1385
1386 let response = make_response(
1387 KrakenWsMethod::AddOrder,
1388 false,
1389 req_id,
1390 None,
1391 Some("Insufficient funds"),
1392 );
1393 harness.state.handle_response(&response, 2_000);
1394
1395 assert_eq!(harness.state.pending_len(), 0);
1396 let event = harness.event_rx.try_recv().expect("event emitted");
1397 match event {
1398 OrderEventAny::Rejected(e) => {
1399 assert_eq!(e.client_order_id, cl_ord_id);
1400 assert_eq!(e.reason, "Insufficient funds");
1401 }
1402 other => panic!("expected Rejected, was {other:?}"),
1403 }
1404 }
1405
1406 #[rstest]
1407 fn test_handle_response_amend_success_emits_order_updated() {
1408 let mut harness = make_harness(60_000);
1409 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1410 register_default_identity(&harness.dispatch_state, cl_ord_id);
1411
1412 let req_id = 11;
1413 let pending = PendingRequest {
1414 operation: PendingOperation::Amend,
1415 client_order_ids: vec![cl_ord_id],
1416 venue_order_ids: vec![Some(VenueOrderId::from(VENUE_ORDER_ID))],
1417 ts_sent_ns: 0,
1418 new_quantity: None,
1419 new_price: None,
1420 new_trigger_price: None,
1421 };
1422 harness.state.pending.insert(req_id, pending);
1423
1424 let response = make_response(
1425 KrakenWsMethod::AmendOrder,
1426 true,
1427 req_id,
1428 Some(VENUE_ORDER_ID),
1429 None,
1430 );
1431 harness.state.handle_response(&response, 3_000);
1432
1433 let event = harness.event_rx.try_recv().expect("event emitted");
1434 match event {
1435 OrderEventAny::Updated(e) => {
1436 assert_eq!(e.client_order_id, cl_ord_id);
1437 assert_eq!(
1438 e.venue_order_id.expect("venue id present").as_str(),
1439 VENUE_ORDER_ID
1440 );
1441 assert_eq!(e.quantity, Quantity::from("0.001"));
1442 }
1443 other => panic!("expected Updated, was {other:?}"),
1444 }
1445 }
1446
1447 #[rstest]
1448 fn test_handle_response_amend_with_new_quantity_emits_new_quantity() {
1449 let mut harness = make_harness(60_000);
1450 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1451 register_default_identity(&harness.dispatch_state, cl_ord_id);
1452
1453 let req_id = 11;
1454 let new_qty = Quantity::from("0.005");
1455 let pending = PendingRequest {
1456 operation: PendingOperation::Amend,
1457 client_order_ids: vec![cl_ord_id],
1458 venue_order_ids: vec![Some(VenueOrderId::from(VENUE_ORDER_ID))],
1459 ts_sent_ns: 0,
1460 new_quantity: Some(new_qty),
1461 new_price: None,
1462 new_trigger_price: None,
1463 };
1464 harness.state.pending.insert(req_id, pending);
1465
1466 let response = make_response(
1467 KrakenWsMethod::AmendOrder,
1468 true,
1469 req_id,
1470 Some(VENUE_ORDER_ID),
1471 None,
1472 );
1473 harness.state.handle_response(&response, 3_500);
1474
1475 let event = harness.event_rx.try_recv().expect("event emitted");
1476 match event {
1477 OrderEventAny::Updated(e) => {
1478 assert_eq!(e.quantity, new_qty, "OrderUpdated must carry new quantity");
1479 }
1480 other => panic!("expected Updated, was {other:?}"),
1481 }
1482
1483 let identity = harness
1484 .dispatch_state
1485 .lookup_identity(&cl_ord_id)
1486 .expect("identity present");
1487 assert_eq!(
1488 identity.quantity, new_qty,
1489 "dispatch identity must be updated for follow-up ops",
1490 );
1491 }
1492
1493 #[rstest]
1494 fn test_handle_response_amend_carries_new_price_and_trigger() {
1495 let mut harness = make_harness(60_000);
1496 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1497 register_default_identity(&harness.dispatch_state, cl_ord_id);
1498
1499 let req_id = 13;
1500 let new_price = Price::from("31000.00");
1501 let new_trigger = Price::from("30500.00");
1502 let pending = PendingRequest {
1503 operation: PendingOperation::Amend,
1504 client_order_ids: vec![cl_ord_id],
1505 venue_order_ids: vec![Some(VenueOrderId::from(VENUE_ORDER_ID))],
1506 ts_sent_ns: 0,
1507 new_quantity: None,
1508 new_price: Some(new_price),
1509 new_trigger_price: Some(new_trigger),
1510 };
1511 harness.state.pending.insert(req_id, pending);
1512
1513 let response = make_response(
1514 KrakenWsMethod::AmendOrder,
1515 true,
1516 req_id,
1517 Some(VENUE_ORDER_ID),
1518 None,
1519 );
1520 harness.state.handle_response(&response, 4_500);
1521
1522 let event = harness.event_rx.try_recv().expect("event emitted");
1523 match event {
1524 OrderEventAny::Updated(e) => {
1525 assert_eq!(
1526 e.price,
1527 Some(new_price),
1528 "OrderUpdated must carry amended price",
1529 );
1530 assert_eq!(
1531 e.trigger_price,
1532 Some(new_trigger),
1533 "OrderUpdated must carry amended trigger price",
1534 );
1535 }
1536 other => panic!("expected Updated, was {other:?}"),
1537 }
1538 }
1539
1540 #[rstest]
1541 fn test_handle_response_amend_failure_emits_order_modify_rejected() {
1542 let mut harness = make_harness(60_000);
1543 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1544 register_default_identity(&harness.dispatch_state, cl_ord_id);
1545
1546 let req_id = 12;
1547 let pending = PendingRequest {
1548 operation: PendingOperation::Amend,
1549 client_order_ids: vec![cl_ord_id],
1550 venue_order_ids: vec![Some(VenueOrderId::from(VENUE_ORDER_ID))],
1551 ts_sent_ns: 0,
1552 new_quantity: None,
1553 new_price: None,
1554 new_trigger_price: None,
1555 };
1556 harness.state.pending.insert(req_id, pending);
1557
1558 let response = make_response(
1559 KrakenWsMethod::AmendOrder,
1560 false,
1561 req_id,
1562 None,
1563 Some("Order not found"),
1564 );
1565 harness.state.handle_response(&response, 4_000);
1566
1567 let event = harness.event_rx.try_recv().expect("event emitted");
1568 match event {
1569 OrderEventAny::ModifyRejected(e) => {
1570 assert_eq!(e.client_order_id, cl_ord_id);
1571 assert_eq!(e.reason, "Order not found");
1572 }
1573 other => panic!("expected ModifyRejected, was {other:?}"),
1574 }
1575 }
1576
1577 #[rstest]
1578 fn test_handle_response_cancel_failure_emits_order_cancel_rejected() {
1579 let mut harness = make_harness(60_000);
1580 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1581 register_default_identity(&harness.dispatch_state, cl_ord_id);
1582
1583 let req_id = 21;
1584 let pending = PendingRequest {
1585 operation: PendingOperation::Cancel,
1586 client_order_ids: vec![cl_ord_id],
1587 venue_order_ids: vec![Some(VenueOrderId::from(VENUE_ORDER_ID))],
1588 ts_sent_ns: 0,
1589 new_quantity: None,
1590 new_price: None,
1591 new_trigger_price: None,
1592 };
1593 harness.state.pending.insert(req_id, pending);
1594
1595 let response = make_response(
1596 KrakenWsMethod::CancelOrder,
1597 false,
1598 req_id,
1599 None,
1600 Some("Unknown order"),
1601 );
1602 harness.state.handle_response(&response, 5_000);
1603
1604 let event = harness.event_rx.try_recv().expect("event emitted");
1605 match event {
1606 OrderEventAny::CancelRejected(e) => {
1607 assert_eq!(e.client_order_id, cl_ord_id);
1608 assert_eq!(e.reason, "Unknown order");
1609 }
1610 other => panic!("expected CancelRejected, was {other:?}"),
1611 }
1612 }
1613
1614 #[rstest]
1615 fn test_handle_response_cancel_success_is_silent() {
1616 let mut harness = make_harness(60_000);
1617 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1618 register_default_identity(&harness.dispatch_state, cl_ord_id);
1619
1620 let req_id = 22;
1621 let pending = PendingRequest {
1622 operation: PendingOperation::Cancel,
1623 client_order_ids: vec![cl_ord_id],
1624 venue_order_ids: vec![Some(VenueOrderId::from(VENUE_ORDER_ID))],
1625 ts_sent_ns: 0,
1626 new_quantity: None,
1627 new_price: None,
1628 new_trigger_price: None,
1629 };
1630 harness.state.pending.insert(req_id, pending);
1631
1632 let response = make_response(KrakenWsMethod::CancelOrder, true, req_id, None, None);
1633 harness.state.handle_response(&response, 6_000);
1634
1635 assert_eq!(harness.state.pending_len(), 0);
1636 assert!(harness.event_rx.try_recv().is_err());
1637 }
1638
1639 #[rstest]
1640 #[case(PendingOperation::Submit)]
1641 #[case(PendingOperation::Amend)]
1642 #[case(PendingOperation::Cancel)]
1643 #[case(PendingOperation::BatchAdd)]
1644 fn test_timeout_emits_no_order_event(#[case] operation: PendingOperation) {
1645 let mut harness = make_harness(60_000);
1646 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1647 register_default_identity(&harness.dispatch_state, cl_ord_id);
1648
1649 let pending = PendingRequest {
1650 operation,
1651 client_order_ids: vec![cl_ord_id],
1652 venue_order_ids: vec![Some(VenueOrderId::from(VENUE_ORDER_ID))],
1653 ts_sent_ns: 0,
1654 new_quantity: None,
1655 new_price: None,
1656 new_trigger_price: None,
1657 };
1658
1659 harness.state.handle_timeout(&pending);
1660
1661 assert!(harness.event_rx.try_recv().is_err());
1662 }
1663
1664 #[tokio::test]
1665 async fn test_late_submit_response_resolves_timed_out_request() {
1666 let mut harness = make_harness(50);
1667 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1668 register_default_identity(&harness.dispatch_state, cl_ord_id);
1669 *harness.auth_token.write().await = Some(SecretString::from("TEST-TOKEN".to_string()));
1670
1671 let params = make_add_order_params("TEST-TOKEN");
1672 let req_id = harness
1673 .state
1674 .submit(params, make_identity(PendingOperation::Submit), 1)
1675 .expect("submit ok");
1676
1677 let payloads = recv_send_payloads_until_cancel(&mut harness.cmd_rx).await;
1678 assert!(
1679 payloads
1680 .iter()
1681 .any(|p| p.expose_secret().contains("\"cancel_order\"")),
1682 );
1683 assert_eq!(harness.state.pending_len(), 1);
1684 assert!(harness.event_rx.try_recv().is_err());
1685
1686 let response = make_response(
1687 KrakenWsMethod::AddOrder,
1688 true,
1689 req_id,
1690 Some(VENUE_ORDER_ID),
1691 None,
1692 );
1693 harness.state.handle_response(&response, 7_000);
1694
1695 let event = harness.event_rx.try_recv().expect("late response event");
1696 match event {
1697 OrderEventAny::Accepted(e) => {
1698 assert_eq!(e.client_order_id, cl_ord_id);
1699 assert_eq!(e.venue_order_id.as_str(), VENUE_ORDER_ID);
1700 }
1701 other => panic!("expected Accepted, was {other:?}"),
1702 }
1703 assert_eq!(harness.state.pending_len(), 0);
1704 }
1705
1706 #[tokio::test]
1707 async fn test_late_submit_rejection_resolves_timed_out_request() {
1708 let mut harness = make_harness(50);
1709 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1710 register_default_identity(&harness.dispatch_state, cl_ord_id);
1711 *harness.auth_token.write().await = Some(SecretString::from("TEST-TOKEN".to_string()));
1712
1713 let params = make_add_order_params("TEST-TOKEN");
1714 let req_id = harness
1715 .state
1716 .submit(params, make_identity(PendingOperation::Submit), 1)
1717 .expect("submit ok");
1718
1719 recv_send_payloads_until_cancel(&mut harness.cmd_rx).await;
1720 assert_eq!(harness.state.pending_len(), 1);
1721 assert!(harness.event_rx.try_recv().is_err());
1722
1723 let response = make_response(
1724 KrakenWsMethod::AddOrder,
1725 false,
1726 req_id,
1727 None,
1728 Some("Insufficient funds"),
1729 );
1730 harness.state.handle_response(&response, 7_000);
1731
1732 let event = harness.event_rx.try_recv().expect("late response event");
1733 match event {
1734 OrderEventAny::Rejected(e) => {
1735 assert_eq!(e.client_order_id, cl_ord_id);
1736 assert_eq!(e.reason, "Insufficient funds");
1737 }
1738 other => panic!("expected Rejected, was {other:?}"),
1739 }
1740 assert_eq!(harness.state.pending_len(), 0);
1741 }
1742
1743 #[rstest]
1744 fn test_handle_response_method_op_mismatch_retains_pending() {
1745 let mut harness = make_harness(60_000);
1746 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
1747 register_default_identity(&harness.dispatch_state, cl_ord_id);
1748
1749 let req_id = 33;
1750 harness
1751 .state
1752 .pending
1753 .insert(req_id, make_identity(PendingOperation::Submit));
1754
1755 let response = make_response(KrakenWsMethod::CancelOrder, true, req_id, None, None);
1756 harness.state.handle_response(&response, 8_000);
1757
1758 assert_eq!(harness.state.pending_len(), 1);
1759 assert!(harness.event_rx.try_recv().is_err());
1760
1761 let response = make_response(
1762 KrakenWsMethod::AddOrder,
1763 true,
1764 req_id,
1765 Some(VENUE_ORDER_ID),
1766 None,
1767 );
1768 harness.state.handle_response(&response, 8_001);
1769
1770 let event = harness
1771 .event_rx
1772 .try_recv()
1773 .expect("matching response event");
1774 match event {
1775 OrderEventAny::Accepted(e) => {
1776 assert_eq!(e.client_order_id, cl_ord_id);
1777 assert_eq!(e.venue_order_id.as_str(), VENUE_ORDER_ID);
1778 }
1779 other => panic!("expected Accepted, was {other:?}"),
1780 }
1781 assert_eq!(harness.state.pending_len(), 0);
1782 }
1783
1784 #[rstest]
1785 fn test_handle_response_batch_add_emits_per_leg_events() {
1786 let mut harness = make_harness(60_000);
1787 let cl_a = ClientOrderId::from("O-A");
1788 let cl_b = ClientOrderId::from("O-B");
1789 register_default_identity(&harness.dispatch_state, cl_a);
1790 register_default_identity(&harness.dispatch_state, cl_b);
1791
1792 let req_id = 50;
1793 let pending = PendingRequest {
1794 operation: PendingOperation::BatchAdd,
1795 client_order_ids: vec![cl_a, cl_b],
1796 venue_order_ids: vec![None, None],
1797 ts_sent_ns: 0,
1798 new_quantity: None,
1799 new_price: None,
1800 new_trigger_price: None,
1801 };
1802 harness.state.pending.insert(req_id, pending);
1803
1804 let response = KrakenWsOrderResponse {
1805 method: KrakenWsMethod::BatchAdd,
1806 req_id: Some(req_id),
1807 success: true,
1808 time_in: None,
1809 time_out: None,
1810 error: None,
1811 result: Some(KrakenWsOrderResult {
1812 order_id: None,
1813 cl_ord_id: None,
1814 order_userref: None,
1815 warning: None,
1816 orders: Some(vec![
1817 KrakenWsBatchOrderResult {
1818 success: true,
1819 order_id: Some("V-A".to_string()),
1820 cl_ord_id: Some("O-A".to_string()),
1821 error: None,
1822 },
1823 KrakenWsBatchOrderResult {
1824 success: false,
1825 order_id: None,
1826 cl_ord_id: Some("O-B".to_string()),
1827 error: Some("Bad price".to_string()),
1828 },
1829 ]),
1830 }),
1831 };
1832 harness.state.handle_response(&response, 9_000);
1833
1834 let first = harness.event_rx.try_recv().expect("first event");
1835 let second = harness.event_rx.try_recv().expect("second event");
1836
1837 match first {
1838 OrderEventAny::Accepted(e) => {
1839 assert_eq!(e.client_order_id, cl_a);
1840 assert_eq!(e.venue_order_id.as_str(), "V-A");
1841 }
1842 other => panic!("expected Accepted, was {other:?}"),
1843 }
1844
1845 match second {
1846 OrderEventAny::Rejected(e) => {
1847 assert_eq!(e.client_order_id, cl_b);
1848 assert_eq!(e.reason, "Bad price");
1849 }
1850 other => panic!("expected Rejected, was {other:?}"),
1851 }
1852 }
1853
1854 #[rstest]
1855 fn test_handle_response_batch_add_matches_legs_by_echoed_cl_ord_id() {
1856 let mut harness = make_harness(60_000);
1857 let cl_a = ClientOrderId::from("O-A");
1858 let cl_b = ClientOrderId::from("O-B");
1859 register_default_identity(&harness.dispatch_state, cl_a);
1860 register_default_identity(&harness.dispatch_state, cl_b);
1861
1862 let req_id = 60;
1863 let pending = PendingRequest {
1864 operation: PendingOperation::BatchAdd,
1865 client_order_ids: vec![cl_a, cl_b],
1866 venue_order_ids: vec![None, None],
1867 ts_sent_ns: 0,
1868 new_quantity: None,
1869 new_price: None,
1870 new_trigger_price: None,
1871 };
1872 harness.state.pending.insert(req_id, pending);
1873
1874 let response = KrakenWsOrderResponse {
1878 method: KrakenWsMethod::BatchAdd,
1879 req_id: Some(req_id),
1880 success: true,
1881 time_in: None,
1882 time_out: None,
1883 error: None,
1884 result: Some(KrakenWsOrderResult {
1885 order_id: None,
1886 cl_ord_id: None,
1887 order_userref: None,
1888 warning: None,
1889 orders: Some(vec![
1890 KrakenWsBatchOrderResult {
1891 success: true,
1892 order_id: Some("V-B".to_string()),
1893 cl_ord_id: Some("O-B".to_string()),
1894 error: None,
1895 },
1896 KrakenWsBatchOrderResult {
1897 success: true,
1898 order_id: Some("V-A".to_string()),
1899 cl_ord_id: Some("O-A".to_string()),
1900 error: None,
1901 },
1902 ]),
1903 }),
1904 };
1905 harness.state.handle_response(&response, 14_000);
1906
1907 let first = harness.event_rx.try_recv().expect("first event");
1908 let second = harness.event_rx.try_recv().expect("second event");
1909 let mut by_cl_ord = std::collections::HashMap::new();
1910
1911 for event in [first, second] {
1912 match event {
1913 OrderEventAny::Accepted(e) => {
1914 by_cl_ord.insert(e.client_order_id, e.venue_order_id);
1915 }
1916 other => panic!("expected Accepted, was {other:?}"),
1917 }
1918 }
1919 assert_eq!(
1920 by_cl_ord.get(&cl_a).map(|v| v.as_str()),
1921 Some("V-A"),
1922 "cl_a must be paired with V-A despite reversed response order",
1923 );
1924 assert_eq!(
1925 by_cl_ord.get(&cl_b).map(|v| v.as_str()),
1926 Some("V-B"),
1927 "cl_b must be paired with V-B despite reversed response order",
1928 );
1929 }
1930
1931 #[rstest]
1932 fn test_handle_response_batch_add_truncated_per_leg_results_rejects_trailing_legs() {
1933 let mut harness = make_harness(60_000);
1934 let cl_a = ClientOrderId::from("O-A");
1935 let cl_b = ClientOrderId::from("O-B");
1936 let cl_c = ClientOrderId::from("O-C");
1937 register_default_identity(&harness.dispatch_state, cl_a);
1938 register_default_identity(&harness.dispatch_state, cl_b);
1939 register_default_identity(&harness.dispatch_state, cl_c);
1940
1941 let req_id = 51;
1942 let pending = PendingRequest {
1943 operation: PendingOperation::BatchAdd,
1944 client_order_ids: vec![cl_a, cl_b, cl_c],
1945 venue_order_ids: vec![None, None, None],
1946 ts_sent_ns: 0,
1947 new_quantity: None,
1948 new_price: None,
1949 new_trigger_price: None,
1950 };
1951 harness.state.pending.insert(req_id, pending);
1952
1953 let response = KrakenWsOrderResponse {
1955 method: KrakenWsMethod::BatchAdd,
1956 req_id: Some(req_id),
1957 success: true,
1958 time_in: None,
1959 time_out: None,
1960 error: None,
1961 result: Some(KrakenWsOrderResult {
1962 order_id: None,
1963 cl_ord_id: None,
1964 order_userref: None,
1965 warning: None,
1966 orders: Some(vec![KrakenWsBatchOrderResult {
1967 success: true,
1968 order_id: Some("V-A".to_string()),
1969 cl_ord_id: Some("O-A".to_string()),
1970 error: None,
1971 }]),
1972 }),
1973 };
1974 harness.state.handle_response(&response, 12_000);
1975
1976 let first = harness.event_rx.try_recv().expect("first event");
1977 let second = harness.event_rx.try_recv().expect("second event");
1978 let third = harness.event_rx.try_recv().expect("third event");
1979
1980 match first {
1981 OrderEventAny::Accepted(e) => assert_eq!(e.client_order_id, cl_a),
1982 other => panic!("expected Accepted for present leg, was {other:?}"),
1983 }
1984
1985 for (event, cl_id) in [(second, cl_b), (third, cl_c)] {
1986 match event {
1987 OrderEventAny::Rejected(e) => {
1988 assert_eq!(
1989 e.client_order_id, cl_id,
1990 "missing-leg rejection cl_ord_id mismatch",
1991 );
1992 assert!(
1993 e.reason.contains("missing per-leg result"),
1994 "expected truncation reason, was {}",
1995 e.reason,
1996 );
1997 }
1998 other => panic!(
1999 "missing per-leg result must reject (not inherit envelope.success), was {other:?}",
2000 ),
2001 }
2002 }
2003 }
2004
2005 fn drain_send_payloads(
2006 rx: &mut tokio::sync::mpsc::UnboundedReceiver<SpotHandlerCommand>,
2007 ) -> Vec<SecretString> {
2008 let mut out = Vec::new();
2009
2010 while let Ok(cmd) = rx.try_recv() {
2011 if let SpotHandlerCommand::SendOrderRequest { payload, .. } = cmd {
2012 out.push(payload);
2013 }
2014 }
2015 out
2016 }
2017
2018 async fn recv_send_payloads_until_cancel(
2022 rx: &mut tokio::sync::mpsc::UnboundedReceiver<SpotHandlerCommand>,
2023 ) -> Vec<SecretString> {
2024 let mut out = Vec::new();
2025
2026 loop {
2027 let cmd = tokio::time::timeout(Duration::from_secs(5), rx.recv())
2028 .await
2029 .expect("timed out awaiting compensating cancel")
2030 .expect("command channel closed");
2031
2032 let SpotHandlerCommand::SendOrderRequest { payload, .. } = cmd else {
2033 continue;
2034 };
2035 let is_cancel = payload.expose_secret().contains("\"cancel_order\"");
2036 out.push(payload);
2037
2038 if is_cancel {
2039 return out;
2040 }
2041 }
2042 }
2043
2044 #[tokio::test]
2045 async fn test_submit_timeout_sends_compensating_cancel() {
2046 let mut harness = make_harness(50);
2047 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
2048 register_default_identity(&harness.dispatch_state, cl_ord_id);
2049 *harness.auth_token.write().await = Some(SecretString::from("TEST-TOKEN".to_string()));
2050
2051 let params = make_add_order_params("TEST-TOKEN");
2052 let identity = make_identity(PendingOperation::Submit);
2053 harness
2054 .state
2055 .submit(params, identity, 1)
2056 .expect("submit ok");
2057
2058 let payloads = recv_send_payloads_until_cancel(&mut harness.cmd_rx).await;
2059 assert!(
2060 payloads
2061 .iter()
2062 .any(|p| p.expose_secret().contains("\"add_order\"")),
2063 "original add_order missing: {payloads:?}",
2064 );
2065 let cancel = payloads
2066 .iter()
2067 .find(|p| p.expose_secret().contains("\"cancel_order\""))
2068 .expect("compensating cancel_order missing");
2069 assert!(
2070 cancel.expose_secret().contains(CLIENT_ORDER_ID),
2071 "compensating cancel must reference cl_ord_id, was {}",
2072 cancel.expose_secret(),
2073 );
2074
2075 assert_eq!(harness.state.pending_len(), 1);
2076 assert!(harness.event_rx.try_recv().is_err());
2077 }
2078
2079 #[tokio::test]
2080 async fn test_compensating_cancel_response_is_silently_dropped() {
2081 let mut harness = make_harness(50);
2085 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
2086 register_default_identity(&harness.dispatch_state, cl_ord_id);
2087 *harness.auth_token.write().await = Some(SecretString::from("TEST-TOKEN".to_string()));
2088
2089 let params = make_add_order_params("TEST-TOKEN");
2090 let identity = make_identity(PendingOperation::Submit);
2091 harness
2092 .state
2093 .submit(params, identity, 1)
2094 .expect("submit ok");
2095
2096 let payloads = recv_send_payloads_until_cancel(&mut harness.cmd_rx).await;
2097
2098 let cancel = payloads
2099 .iter()
2100 .find(|p| p.expose_secret().contains("\"cancel_order\""))
2101 .expect("compensating cancel missing");
2102 let cancel_value: serde_json::Value =
2103 serde_json::from_str(cancel.expose_secret()).expect("valid json");
2104 let cancel_req_id = cancel_value["req_id"].as_u64().expect("req_id present");
2105
2106 for success in [true, false] {
2107 let response = KrakenWsOrderResponse {
2108 method: KrakenWsMethod::CancelOrder,
2109 req_id: Some(cancel_req_id),
2110 success,
2111 time_in: None,
2112 time_out: None,
2113 error: (!success).then(|| "Unknown order".to_string()),
2114 result: None,
2115 };
2116 harness.state.handle_response(&response, 9_000);
2117 }
2118
2119 assert!(
2120 harness.event_rx.try_recv().is_err(),
2121 "compensating-cancel responses must not surface events to strategies",
2122 );
2123 assert_eq!(harness.state.pending_len(), 1);
2124 }
2125
2126 #[rstest]
2127 fn test_submit_timeout_without_token_skips_compensating_cancel() {
2128 let mut harness = make_harness(60_000);
2129 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
2130 register_default_identity(&harness.dispatch_state, cl_ord_id);
2131 let identity = make_identity(PendingOperation::Submit);
2132
2133 harness.state.handle_timeout(&identity);
2134
2135 let payloads = drain_send_payloads(&mut harness.cmd_rx);
2136 assert!(
2137 payloads
2138 .iter()
2139 .all(|p| !p.expose_secret().contains("\"cancel_order\"")),
2140 "no compensating cancel expected without token, was {payloads:?}",
2141 );
2142 }
2143
2144 #[tokio::test]
2145 async fn test_batch_add_timeout_sends_compensating_cancel_for_all_legs() {
2146 let mut harness = make_harness(50);
2147 let cl_a = ClientOrderId::from("O-A");
2148 let cl_b = ClientOrderId::from("O-B");
2149 register_default_identity(&harness.dispatch_state, cl_a);
2150 register_default_identity(&harness.dispatch_state, cl_b);
2151 *harness.auth_token.write().await = Some(SecretString::from("TEST-TOKEN".to_string()));
2152
2153 let params = KrakenWsBatchAddParams {
2154 symbol: "BTC/USD".to_string(),
2155 orders: vec![],
2156 token: SecretString::from("TEST-TOKEN"),
2157 };
2158 let identity = PendingRequest {
2159 operation: PendingOperation::BatchAdd,
2160 client_order_ids: vec![cl_a, cl_b],
2161 venue_order_ids: vec![None, None],
2162 ts_sent_ns: 0,
2163 new_quantity: None,
2164 new_price: None,
2165 new_trigger_price: None,
2166 };
2167 harness
2168 .state
2169 .batch_add(params, identity, 1)
2170 .expect("batch ok");
2171
2172 let payloads = recv_send_payloads_until_cancel(&mut harness.cmd_rx).await;
2173 let cancel = payloads
2174 .iter()
2175 .find(|p| p.expose_secret().contains("\"cancel_order\""))
2176 .expect("compensating cancel missing");
2177 assert!(cancel.expose_secret().contains("O-A") && cancel.expose_secret().contains("O-B"),);
2178 assert_eq!(harness.state.pending_len(), 1);
2179 assert!(harness.event_rx.try_recv().is_err());
2180
2181 let batch_req_id = payloads
2182 .iter()
2183 .find(|p| p.expose_secret().contains("\"batch_add\""))
2184 .and_then(|p| serde_json::from_str::<serde_json::Value>(p.expose_secret()).ok())
2185 .and_then(|v| v["req_id"].as_u64())
2186 .expect("batch req_id missing");
2187 let response = KrakenWsOrderResponse {
2188 method: KrakenWsMethod::BatchAdd,
2189 req_id: Some(batch_req_id),
2190 success: true,
2191 time_in: None,
2192 time_out: None,
2193 error: None,
2194 result: Some(KrakenWsOrderResult {
2195 order_id: None,
2196 cl_ord_id: None,
2197 order_userref: None,
2198 warning: None,
2199 orders: Some(vec![
2200 KrakenWsBatchOrderResult {
2201 success: false,
2202 order_id: None,
2203 cl_ord_id: Some("O-B".to_string()),
2204 error: Some("Bad price".to_string()),
2205 },
2206 KrakenWsBatchOrderResult {
2207 success: true,
2208 order_id: Some("V-A".to_string()),
2209 cl_ord_id: Some("O-A".to_string()),
2210 error: None,
2211 },
2212 ]),
2213 }),
2214 };
2215 harness.state.handle_response(&response, 10_000);
2216
2217 let first = harness.event_rx.try_recv().expect("first late event");
2218 let second = harness.event_rx.try_recv().expect("second late event");
2219 let mut accepted = None;
2220 let mut rejected = None;
2221
2222 for event in [first, second] {
2223 match event {
2224 OrderEventAny::Accepted(e) => {
2225 accepted = Some((e.client_order_id, e.venue_order_id));
2226 }
2227 OrderEventAny::Rejected(e) => {
2228 rejected = Some((e.client_order_id, e.reason));
2229 }
2230 other => panic!("expected Accepted or Rejected, was {other:?}"),
2231 }
2232 }
2233 assert_eq!(
2234 accepted.map(|(cl, venue)| (cl, venue.to_string())),
2235 Some((cl_a, "V-A".to_string()))
2236 );
2237 assert_eq!(
2238 rejected.map(|(cl, reason)| (cl, reason.to_string())),
2239 Some((cl_b, "Bad price".to_string()))
2240 );
2241 assert_eq!(harness.state.pending_len(), 0);
2242 }
2243
2244 #[tokio::test]
2245 async fn test_clear_removes_timed_out_request() {
2246 let mut harness = make_harness(50);
2247 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
2248 register_default_identity(&harness.dispatch_state, cl_ord_id);
2249 *harness.auth_token.write().await = Some(SecretString::from("TEST-TOKEN".to_string()));
2250
2251 let params = make_add_order_params("TEST-TOKEN");
2252 harness
2253 .state
2254 .submit(params, make_identity(PendingOperation::Submit), 1)
2255 .expect("submit ok");
2256
2257 recv_send_payloads_until_cancel(&mut harness.cmd_rx).await;
2258 assert_eq!(harness.state.pending_len(), 1);
2259
2260 harness.state.clear();
2261
2262 assert_eq!(harness.state.pending_len(), 0);
2263 }
2264
2265 #[tokio::test]
2266 async fn test_reset_cancellation_token_keeps_new_timeout_pending() {
2267 let mut harness = make_harness(50);
2268 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
2269 register_default_identity(&harness.dispatch_state, cl_ord_id);
2270 *harness.auth_token.write().await = Some(SecretString::from("TEST-TOKEN".to_string()));
2271 harness.pending_tasks.begin_shutdown();
2272 harness
2273 .pending_tasks
2274 .finish_shutdown(Duration::from_secs(1), Duration::from_secs(1))
2275 .await
2276 .expect("finish old timeout generation");
2277 harness
2278 .pending_tasks
2279 .start_generation()
2280 .expect("start timeout generation");
2281 let pending_spawner = harness
2282 .pending_tasks
2283 .spawner()
2284 .expect("pending task spawner");
2285 harness.state.reset_task_spawner(pending_spawner);
2286
2287 harness
2288 .state
2289 .submit(
2290 make_add_order_params("TEST-TOKEN"),
2291 make_identity(PendingOperation::Submit),
2292 1,
2293 )
2294 .expect("submit ok");
2295
2296 recv_send_payloads_until_cancel(&mut harness.cmd_rx).await;
2297
2298 assert_eq!(harness.state.pending_len(), 1);
2299 assert!(harness.event_rx.try_recv().is_err());
2300 }
2301
2302 #[tokio::test]
2303 async fn test_task_group_shutdown_aborts_pending_timeout() {
2304 let harness = make_harness(60_000);
2305 let cl_ord_id = ClientOrderId::from(CLIENT_ORDER_ID);
2306 register_default_identity(&harness.dispatch_state, cl_ord_id);
2307
2308 let params = KrakenWsAddOrderParams {
2309 order_type: KrakenOrderType::Limit,
2310 side: KrakenOrderSide::Buy,
2311 order_qty: dec!(0.001),
2312 symbol: "BTC/USD".to_string(),
2313 token: SecretString::default(),
2314 limit_price: Some(dec!(50000)),
2315 time_in_force: None,
2316 expire_time: None,
2317 cl_ord_id: Some(CLIENT_ORDER_ID.to_string()),
2318 post_only: None,
2319 reduce_only: None,
2320 leverage: None,
2321 trigger: None,
2322 conditional: None,
2323 };
2324 let identity = make_identity(PendingOperation::Submit);
2325 harness
2326 .state
2327 .submit(params, identity, 1)
2328 .expect("submit ok");
2329 assert_eq!(harness.state.pending_len(), 1);
2330
2331 harness.pending_tasks.begin_shutdown();
2332
2333 nautilus_common::testing::wait_until_async(
2336 || {
2337 let state = Arc::clone(&harness.state);
2338 async move { state.pending_len() == 0 }
2339 },
2340 Duration::from_secs(5),
2341 )
2342 .await;
2343
2344 assert_eq!(
2345 harness.state.pending_len(),
2346 0,
2347 "pending entry must be cleared on cancellation",
2348 );
2349 }
2350}
2351
2352#[cfg(test)]
2353mod property_tests {
2354 use nautilus_model::identifiers::ClientOrderId;
2355 use proptest::prelude::*;
2356 use rstest::rstest;
2357
2358 use super::{tests::make_harness, *};
2359 use crate::websocket::spot_v2::messages::{KrakenWsBatchOrderResult, KrakenWsOrderResult};
2360
2361 proptest! {
2362 #[rstest]
2363 fn no_pending_leak_on_random_response_interleaving(
2364 ops in proptest::collection::vec(
2365 prop_oneof![
2366 Just((PendingOperation::Submit, true, 1usize)),
2367 Just((PendingOperation::Submit, false, 1usize)),
2368 Just((PendingOperation::Amend, true, 1usize)),
2369 Just((PendingOperation::Amend, false, 1usize)),
2370 Just((PendingOperation::Cancel, true, 1usize)),
2371 Just((PendingOperation::Cancel, false, 1usize)),
2372 (2usize..=4usize).prop_map(|n| (PendingOperation::BatchAdd, true, n)),
2373 (2usize..=4usize).prop_map(|n| (PendingOperation::BatchAdd, false, n)),
2374 ],
2375 1..50usize,
2376 )
2377 ) {
2378 let h = make_harness(60_000);
2379 let state = &h.state;
2380 let mut req_ids = Vec::new();
2381
2382 for (op, success, leg_count) in &ops {
2383 let req_id = state.next_req_id();
2384 let client_order_ids: Vec<ClientOrderId> = (0..*leg_count)
2385 .map(|i| ClientOrderId::from(format!("O-{req_id}-{i}").as_str()))
2386 .collect();
2387 let venue_order_ids = vec![None; *leg_count];
2388 state.pending.insert(req_id, PendingRequest {
2389 operation: *op,
2390 client_order_ids: client_order_ids.clone(),
2391 venue_order_ids,
2392 ts_sent_ns: 0,
2393 new_quantity: None,
2394 new_price: None,
2395 new_trigger_price: None,
2396 });
2397 req_ids.push((req_id, *op, *success, client_order_ids));
2398 }
2399 let mut shuffled = req_ids.clone();
2400 shuffled.reverse();
2401 for (req_id, op, success, client_order_ids) in shuffled {
2402 let method = match op {
2403 PendingOperation::Submit => KrakenWsMethod::AddOrder,
2404 PendingOperation::Amend => KrakenWsMethod::AmendOrder,
2405 PendingOperation::Cancel => KrakenWsMethod::CancelOrder,
2406 PendingOperation::BatchAdd => KrakenWsMethod::BatchAdd,
2407 };
2408 let result = if op == PendingOperation::BatchAdd {
2409 Some(KrakenWsOrderResult {
2410 order_id: None,
2411 cl_ord_id: None,
2412 order_userref: None,
2413 warning: None,
2414 orders: Some(client_order_ids
2415 .iter()
2416 .enumerate()
2417 .map(|(i, cid)| KrakenWsBatchOrderResult {
2418 success,
2419 order_id: success.then(|| format!("V-{req_id}-{i}")),
2420 cl_ord_id: Some(cid.as_str().to_string()),
2421 error: (!success).then(|| "test-error".to_string()),
2422 })
2423 .collect()),
2424 })
2425 } else {
2426 None
2427 };
2428 let response = KrakenWsOrderResponse {
2429 method,
2430 req_id: Some(req_id),
2431 success,
2432 time_in: None,
2433 time_out: None,
2434 error: if success {
2435 None
2436 } else {
2437 Some("test-error".to_string())
2438 },
2439 result,
2440 };
2441 state.handle_response(&response, 1);
2442 }
2443 prop_assert_eq!(state.pending_len(), 0);
2444 }
2445 }
2446}