Skip to main content

nautilus_kraken/websocket/dispatch/
spot_orders.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! WebSocket order-request dispatch state for Kraken Spot v2.
17
18use 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    /// Pending add_order request.
58    Submit,
59    /// Pending amend_order request.
60    Amend,
61    /// Pending cancel_order request.
62    Cancel,
63    /// Pending batch_add request.
64    BatchAdd,
65}
66
67#[derive(Debug, Clone)]
68pub struct PendingRequest {
69    /// The pending operation type.
70    pub operation: PendingOperation,
71    /// Client order IDs associated with this request.
72    pub client_order_ids: Vec<ClientOrderId>,
73    /// Venue order IDs associated with this request, if known.
74    pub venue_order_ids: Vec<Option<VenueOrderId>>,
75    /// UNIX nanosecond timestamp when the request was sent.
76    pub ts_sent_ns: u64,
77    /// New quantity carried for amend operations so the success-path
78    /// `OrderUpdated` event reflects the requested change rather than the
79    /// originally registered quantity. `None` for non-amend operations or
80    /// amends that do not modify quantity.
81    pub new_quantity: Option<Quantity>,
82    /// New limit price carried for amend operations so the success-path
83    /// `OrderUpdated` event surfaces the amended price to strategies.
84    /// `None` for non-amend operations or amends that do not modify price.
85    pub new_price: Option<Price>,
86    /// New trigger price carried for amend operations on conditional orders.
87    /// `None` for non-amend operations or amends that do not modify the
88    /// trigger price.
89    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    /// Shared handle to the WS handler cmd_tx. Read at send time, not at
98    /// construction: `connect()` swaps the inner sender, and the
99    /// post-`new()` placeholder's receiver is already dropped.
100    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    /// WS auth token shared with the client; used to build compensating
106    /// cancels when a submit request times out.
107    auth_token: Arc<tokio::sync::RwLock<Option<SecretString>>>,
108    task_spawner: RwLock<TaskSpawner>,
109    /// Clock used to stamp local timeout diagnostics.
110    clock: &'static AtomicTime,
111}
112
113impl OrderRequestState {
114    /// Creates a new [`OrderRequestState`].
115    #[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    /// Reads a clone of the current cmd_tx. Returns `None` only when the
146    /// handle's `RwLock` is being written to (connect/disconnect window).
147    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    /// Returns the next request ID and advances the counter.
152    pub fn next_req_id(&self) -> u64 {
153        self.req_id_counter.fetch_add(1, Ordering::Relaxed) + 1
154    }
155
156    /// Sends an add_order request over the WebSocket transport.
157    ///
158    /// # Errors
159    ///
160    /// Returns an error if the JSON envelope fails to serialize or if the
161    /// handler command channel is closed.
162    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    /// Sends an amend_order request over the WebSocket transport.
180    ///
181    /// # Errors
182    ///
183    /// Returns an error if serialization fails or the handler command channel is closed.
184    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    /// Sends a cancel_order request over the WebSocket transport.
202    ///
203    /// # Errors
204    ///
205    /// Returns an error if serialization fails or the handler command channel is closed.
206    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    /// Sends a batch_add request over the WebSocket transport.
224    ///
225    /// # Errors
226    ///
227    /// Returns an error if serialization fails or the handler command channel is closed.
228    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    /// Routes an order-method WebSocket response to the correct event emitter.
318    ///
319    /// `ts_event_ns` is the local receipt time. Kraken's `time_in`/`time_out`
320    /// are ignored to keep event ordering monotonic against the local clock.
321    /// Timed-out requests remain correlated until a definitive response arrives.
322    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    /// Sends a best-effort `cancel_order` over the WebSocket after a Submit or
405    /// BatchAdd request has timed out, defending against the case where the
406    /// venue accepted the order but the response was delayed past the
407    /// configured timeout window.
408    ///
409    /// Fire-and-forget: the response is silently dropped because no `pending`
410    /// entry is registered for the cancel `req_id`. If the auth token is not
411    /// available or the command channel is closed the cancel is skipped and
412    /// the original request remains resolvable by a late response or
413    /// reconciliation.
414    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        // An invalid ID is not an absent one: the outcome is ambiguous, so the pending ID must not
580        // vouch for it and the executions feed or reconciliation acknowledges the amend.
581        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        // Match per-leg results by the cl_ord_id Kraken echoes back rather than
716        // relying purely on positional alignment with the legs we sent. Echoed
717        // matches are robust against the venue reordering or omitting entries
718        // in the response array; positional fallback covers the (currently
719        // dominant) case where the echoed cl_ord_id is missing.
720        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    /// Forwards an order event to the execution-engine channel.
793    ///
794    /// A send failure means the receiver has been dropped, which only happens
795    /// during shutdown after the forwarder task has exited. Events lost in
796    /// that window are recovered on the next start by the reconciliation
797    /// engine (`open_check_interval_secs`), which queries the venue for any
798    /// orders or fills the local cache is missing. The error log preserves
799    /// operator visibility for the (rare) shutdown-race case.
800    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        // Regression: dispatcher built before connect() must observe the
1019        // live cmd_tx after the swap, not the dropped placeholder.
1020        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    /// A success carrying an order ID the model cannot hold proves neither acceptance nor rejection,
1200    /// so the executions feed or reconciliation resolves the order.
1201    #[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    /// An invalid ID differs from an absent one, which falls back to the pending ID: nothing here
1222    /// proves the amend, so it neither emits an update nor moves the tracked quantity.
1223    #[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    /// A reply that names no order leaves the pending ID to identify it.
1258    #[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    /// A success leg with an invalid ID emits nothing, a failed leg still rejects, and neither
1293    /// disturbs a valid sibling.
1294    #[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        // Vendor returns per-leg results in REVERSE order vs sent. Echo-based
1875        // matching must attribute V-B to cl_b and V-A to cl_a regardless of
1876        // index alignment.
1877        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        // Vendor returns envelope.success=true but only one per-leg entry for three sent.
1954        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    // The compensating cancel is the last command the timeout task emits, so
2019    // awaiting it means timeout handling is complete without racing a fixed
2020    // sleep against the global runtime.
2021    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        // The compensating cancel after a submit timeout is fire-and-forget;
2082        // its response must not surface an event or resolve the original
2083        // request correlation.
2084        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        // Cancellation clears the pending entry from a task on the global runtime,
2334        // so poll the condition rather than racing a fixed sleep.
2335        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}