Skip to main content

nautilus_architect_ax/websocket/orders/
handler.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//! Orders WebSocket message handler for Ax.
17
18use std::{
19    collections::VecDeque,
20    sync::{
21        Arc,
22        atomic::{AtomicBool, Ordering},
23    },
24    time::Duration,
25};
26
27use ahash::AHashMap;
28use dashmap::DashMap;
29use nautilus_core::UUID4;
30use nautilus_model::identifiers::{ClientOrderId, VenueOrderId};
31use nautilus_network::websocket::{AuthTracker, WebSocketClient};
32use tokio_tungstenite::tungstenite::Message;
33use ustr::Ustr;
34
35use crate::{
36    common::enums::AxOrderRequestType,
37    websocket::{
38        messages::{
39            AxOrdersWsFrame, AxOrdersWsMessage, AxWsCancelOrder, AxWsError, AxWsGetOpenOrders,
40            AxWsListResponse, AxWsOrderEvent, AxWsOrderResponse, AxWsPlaceOrder, OrderMetadata,
41        },
42        parse::parse_order_message,
43    },
44};
45
46const LOGIN_TIMEOUT: Duration = Duration::from_secs(5);
47
48/// Simple tracking info for pending WebSocket orders.
49#[derive(Clone, Debug)]
50pub struct WsOrderInfo {
51    /// Client order ID for correlation.
52    pub client_order_id: ClientOrderId,
53    /// Instrument symbol.
54    pub symbol: Ustr,
55    /// Numeric AX client ID.
56    pub cid: u64,
57}
58
59#[derive(Debug)]
60enum OrderSendError {
61    NotSent(String),
62    Ambiguous(String),
63}
64
65impl core::fmt::Display for OrderSendError {
66    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
67        match self {
68            Self::NotSent(message) | Self::Ambiguous(message) => f.write_str(message),
69        }
70    }
71}
72
73/// Commands sent from the outer client to the inner orders handler.
74#[derive(Debug)]
75pub enum HandlerCommand {
76    /// Set the WebSocket client for this handler.
77    SetClient(WebSocketClient),
78    /// Disconnect the WebSocket connection.
79    Disconnect,
80    /// Mark the current handshake-authenticated session as ready.
81    SessionAuthenticated,
82    /// Place an order.
83    PlaceOrder {
84        request_id: i64,
85        order: AxWsPlaceOrder,
86        order_info: WsOrderInfo,
87    },
88    /// Cancel an order.
89    CancelOrder {
90        request_id: i64,
91        order_id: String,
92        client_order_id: ClientOrderId,
93        command_id: Option<UUID4>,
94    },
95    /// Get open orders.
96    GetOpenOrders { request_id: i64 },
97}
98
99/// Orders feed handler that processes WebSocket messages.
100///
101/// Runs in a dedicated Tokio task and owns the WebSocket client exclusively.
102/// Emits raw venue types for downstream consumers to parse into domain events.
103pub(crate) struct AxOrdersWsFeedHandler {
104    signal: Arc<AtomicBool>,
105    inner: Option<WebSocketClient>,
106    cmd_rx: tokio::sync::mpsc::UnboundedReceiver<HandlerCommand>,
107    raw_rx: tokio::sync::mpsc::UnboundedReceiver<(u64, Message)>,
108    auth_tracker: AuthTracker,
109    cancel_on_disconnect: Option<bool>,
110    awaiting_login: bool,
111    authenticated_epoch: Option<u64>,
112    login_deadline: Option<tokio::time::Instant>,
113    session_failed: bool,
114    pending_orders: AHashMap<i64, WsOrderInfo>,
115    message_queue: VecDeque<AxOrdersWsMessage>,
116    orders_metadata: Arc<DashMap<ClientOrderId, OrderMetadata>>,
117    venue_to_client_order_id: Arc<DashMap<VenueOrderId, ClientOrderId>>,
118    has_authenticated_session: bool,
119    needs_session_restore: bool,
120}
121
122impl AxOrdersWsFeedHandler {
123    /// Creates a new [`AxOrdersWsFeedHandler`] instance.
124    #[must_use]
125    pub(crate) fn new(
126        signal: Arc<AtomicBool>,
127        cmd_rx: tokio::sync::mpsc::UnboundedReceiver<HandlerCommand>,
128        raw_rx: tokio::sync::mpsc::UnboundedReceiver<(u64, Message)>,
129        auth_tracker: AuthTracker,
130        cancel_on_disconnect: Option<bool>,
131        orders_metadata: Arc<DashMap<ClientOrderId, OrderMetadata>>,
132        venue_to_client_order_id: Arc<DashMap<VenueOrderId, ClientOrderId>>,
133    ) -> Self {
134        Self {
135            signal,
136            inner: None,
137            cmd_rx,
138            raw_rx,
139            auth_tracker,
140            cancel_on_disconnect,
141            awaiting_login: cancel_on_disconnect.is_some(),
142            authenticated_epoch: None,
143            login_deadline: cancel_on_disconnect
144                .is_some()
145                .then(|| tokio::time::Instant::now() + LOGIN_TIMEOUT),
146            session_failed: false,
147            pending_orders: AHashMap::new(),
148            message_queue: VecDeque::new(),
149            orders_metadata,
150            venue_to_client_order_id,
151            has_authenticated_session: false,
152            needs_session_restore: false,
153        }
154    }
155
156    fn restore_authenticated_session(&mut self) {
157        if self.has_authenticated_session {
158            log::debug!("Restoring authenticated session after reconnection");
159
160            // The reconnect handshake has already succeeded with the current Bearer header.
161            self.auth_tracker.succeed();
162            self.message_queue
163                .push_back(AxOrdersWsMessage::Authenticated);
164            log::debug!("Authenticated session restored");
165        } else {
166            log::warn!("Cannot restore authentication before the initial session succeeds");
167        }
168    }
169
170    /// Returns the next message from the handler.
171    ///
172    /// This method blocks until a message is available or the handler is stopped.
173    pub(crate) async fn next(&mut self) -> Option<AxOrdersWsMessage> {
174        loop {
175            if self.needs_session_restore && self.message_queue.is_empty() {
176                self.needs_session_restore = false;
177                self.restore_authenticated_session();
178            }
179
180            if let Some(msg) = self.message_queue.pop_front() {
181                return Some(msg);
182            }
183
184            if self.awaiting_login
185                && self
186                    .login_deadline
187                    .is_some_and(|deadline| deadline <= tokio::time::Instant::now())
188            {
189                let messages = self.fail_login("Orders WebSocket login timed out".to_string());
190                self.message_queue.extend(messages);
191            }
192
193            if self.session_failed && self.message_queue.is_empty() {
194                self.cmd_rx.close();
195
196                while let Some(cmd) = self.cmd_rx.recv().await {
197                    self.handle_command(cmd).await;
198                }
199
200                if let Some(msg) = self.message_queue.pop_front() {
201                    return Some(msg);
202                }
203
204                if let Some(inner) = self.inner.take() {
205                    inner.disconnect().await;
206                }
207
208                return None;
209            }
210
211            tokio::select! {
212                biased;
213                Some(cmd) = self.cmd_rx.recv() => {
214                    self.handle_command(cmd).await;
215                }
216
217                () = tokio::time::sleep(std::time::Duration::from_millis(100)) => {
218                    if self.signal.load(Ordering::Acquire) {
219                        log::debug!("Stop signal received during idle period");
220                        return None;
221                    }
222                }
223
224                msg = self.raw_rx.recv() => {
225                    let (epoch, msg) = match msg {
226                        Some(msg) => msg,
227                        None => {
228                            log::debug!("WebSocket stream closed");
229                            if self.awaiting_login {
230                                self.auth_tracker.fail("Orders WebSocket closed before session login");
231                            }
232                            return None;
233                        }
234                    };
235
236                    if let Message::Ping(data) = &msg {
237                        log::trace!("Received ping frame with {} bytes", data.len());
238
239                        if let Some(client) = &self.inner
240                            && let Err(e) = client.send_pong(data.to_vec()).await
241                        {
242                            log::warn!("Failed to send pong frame: {e}");
243                        }
244                        continue;
245                    }
246
247                    if let Some(messages) = self.parse_raw_message(epoch, msg) {
248                        self.message_queue.extend(messages);
249                    }
250
251                    if self.signal.load(Ordering::Acquire) {
252                        log::debug!("Stop signal received");
253                        return None;
254                    }
255                }
256            }
257        }
258    }
259
260    async fn handle_command(&mut self, cmd: HandlerCommand) {
261        match cmd {
262            HandlerCommand::SetClient(client) => {
263                log::debug!("WebSocketClient received by handler");
264                self.inner = Some(client);
265            }
266            HandlerCommand::Disconnect => {
267                log::debug!("Disconnect command received");
268                self.auth_tracker.fail("Disconnected");
269
270                if let Some(inner) = self.inner.take() {
271                    inner.disconnect().await;
272                }
273            }
274            HandlerCommand::SessionAuthenticated => {
275                log::debug!("Session authenticated command received");
276                self.has_authenticated_session = true;
277                self.awaiting_login = false;
278                self.auth_tracker.succeed();
279                self.message_queue
280                    .push_back(AxOrdersWsMessage::Authenticated);
281            }
282            HandlerCommand::PlaceOrder {
283                request_id,
284                order,
285                order_info,
286            } => {
287                log::debug!(
288                    "PlaceOrder command received: request_id={request_id}, symbol={}",
289                    order.s
290                );
291                self.pending_orders.insert(request_id, order_info.clone());
292
293                if let Err(e) = self.send_json(&order).await {
294                    log::error!("Failed to send place order message: {e}");
295
296                    match e {
297                        OrderSendError::NotSent(reason) => {
298                            self.pending_orders.remove(&request_id);
299                            self.message_queue
300                                .push_back(AxOrdersWsMessage::PlaceOrderError {
301                                    client_order_id: order_info.client_order_id,
302                                    reason,
303                                });
304                        }
305                        OrderSendError::Ambiguous(reason) => {
306                            self.message_queue
307                                .push_back(AxOrdersWsMessage::Error(AxWsError::new(format!(
308                                    "Failed to send place order for {}: {reason}",
309                                    order_info.client_order_id
310                                ))));
311                        }
312                    }
313                }
314            }
315            HandlerCommand::CancelOrder {
316                request_id,
317                order_id,
318                client_order_id,
319                command_id,
320            } => {
321                log::debug!(
322                    "CancelOrder command received: request_id={request_id}, order_id={order_id}"
323                );
324                self.send_cancel_order(request_id, &order_id, client_order_id, command_id)
325                    .await;
326            }
327            HandlerCommand::GetOpenOrders { request_id } => {
328                log::debug!("GetOpenOrders command received: request_id={request_id}");
329                self.send_get_open_orders(request_id).await;
330            }
331        }
332    }
333
334    async fn send_cancel_order(
335        &mut self,
336        request_id: i64,
337        order_id: &str,
338        client_order_id: ClientOrderId,
339        command_id: Option<UUID4>,
340    ) {
341        let msg = AxWsCancelOrder {
342            rid: request_id,
343            t: AxOrderRequestType::CancelOrder,
344            oid: order_id.to_string(),
345        };
346
347        if let Err(e) = self.send_json(&msg).await {
348            log::error!("Failed to send cancel order message: {e}");
349
350            match e {
351                OrderSendError::NotSent(reason) => {
352                    self.message_queue
353                        .push_back(AxOrdersWsMessage::CancelOrderError {
354                            client_order_id,
355                            reason,
356                            command_id,
357                        });
358                }
359                OrderSendError::Ambiguous(reason) => {
360                    self.message_queue
361                        .push_back(AxOrdersWsMessage::Error(AxWsError::new(format!(
362                            "Failed to send cancel for order {order_id}: {reason}"
363                        ))));
364                }
365            }
366        }
367    }
368
369    async fn send_get_open_orders(&mut self, request_id: i64) {
370        let msg = AxWsGetOpenOrders {
371            rid: request_id,
372            t: AxOrderRequestType::GetOpenOrders,
373        };
374
375        if let Err(e) = self.send_json(&msg).await {
376            let reason = match e {
377                OrderSendError::NotSent(reason) | OrderSendError::Ambiguous(reason) => reason,
378            };
379
380            log::error!("Failed to send get open orders message: {reason}");
381            self.message_queue
382                .push_back(AxOrdersWsMessage::Error(AxWsError::new(format!(
383                    "Failed to send get open orders request: {reason}"
384                ))));
385        }
386    }
387
388    async fn send_json<T: serde::Serialize>(&self, msg: &T) -> Result<(), OrderSendError> {
389        if self.awaiting_login {
390            return Err(OrderSendError::NotSent(
391                "Orders WebSocket session login pending".to_string(),
392            ));
393        }
394
395        if self.session_failed {
396            return Err(OrderSendError::NotSent(
397                "Orders WebSocket session authentication failed".to_string(),
398            ));
399        }
400
401        let Some(inner) = &self.inner else {
402            return Err(OrderSendError::NotSent(
403                "No WebSocket client available".to_string(),
404            ));
405        };
406
407        let payload =
408            serde_json::to_string(msg).map_err(|e| OrderSendError::NotSent(e.to_string()))?;
409        log::trace!("Sending WebSocket payload ({} bytes)", payload.len());
410
411        if self.cancel_on_disconnect.is_some() {
412            let expected_epoch = self.authenticated_epoch.ok_or_else(|| {
413                OrderSendError::NotSent(
414                    "No authenticated orders WebSocket session available".to_string(),
415                )
416            })?;
417
418            if inner.connection_epoch() != expected_epoch {
419                return Err(OrderSendError::Ambiguous(
420                    "Orders WebSocket session changed before login".to_string(),
421                ));
422            }
423
424            return inner
425                .send_text_on_connection(payload, None, expected_epoch)
426                .await
427                .map_err(|e| OrderSendError::Ambiguous(e.to_string()));
428        }
429
430        inner
431            .send_text(payload, None)
432            .await
433            .map_err(|e| OrderSendError::Ambiguous(e.to_string()))
434    }
435
436    fn parse_raw_message(&mut self, epoch: u64, msg: Message) -> Option<Vec<AxOrdersWsMessage>> {
437        match msg {
438            Message::Text(text) => {
439                if text == nautilus_network::RECONNECTED {
440                    log::info!("Received WebSocket reconnected signal");
441
442                    if self.cancel_on_disconnect.is_some() {
443                        let has_current_login = self.authenticated_epoch.is_some()
444                            && !self.awaiting_login
445                            && self.authenticated_epoch == Some(epoch);
446
447                        if !has_current_login {
448                            self.awaiting_login = true;
449                            self.authenticated_epoch = None;
450                            self.login_deadline = Some(tokio::time::Instant::now() + LOGIN_TIMEOUT);
451                            self.auth_tracker.invalidate();
452                        }
453                    } else {
454                        self.auth_tracker.fail("Reconnecting");
455                        self.needs_session_restore = true;
456                    }
457
458                    return Some(vec![AxOrdersWsMessage::Reconnected]);
459                }
460
461                log::trace!("Raw websocket message: {text}");
462
463                let raw_msg: AxOrdersWsFrame = match parse_order_message(&text) {
464                    Ok(v) => v,
465                    Err(e) => {
466                        log::error!("Failed to parse WebSocket message: {e}: {text}");
467                        return None;
468                    }
469                };
470
471                self.handle_raw_message(epoch, raw_msg)
472            }
473            Message::Binary(data) => {
474                log::debug!("Received binary message with {} bytes", data.len());
475                None
476            }
477            Message::Close(_) => {
478                log::debug!("Received close message, waiting for reconnection");
479                None
480            }
481            _ => None,
482        }
483    }
484
485    fn handle_raw_message(
486        &mut self,
487        epoch: u64,
488        raw_msg: AxOrdersWsFrame,
489    ) -> Option<Vec<AxOrdersWsMessage>> {
490        match raw_msg {
491            AxOrdersWsFrame::Error(err) => {
492                log::warn!(
493                    "Order error response: rid={} code={:?} msg={:?}",
494                    err.rid,
495                    err.err.code,
496                    err.err.msg
497                );
498
499                Some(vec![AxOrdersWsMessage::Error(err.into())])
500            }
501            AxOrdersWsFrame::Response(resp) => self.handle_response(epoch, resp),
502            AxOrdersWsFrame::Event(event) => self.handle_event(*event),
503        }
504    }
505
506    fn handle_response(
507        &mut self,
508        epoch: u64,
509        resp: AxWsOrderResponse,
510    ) -> Option<Vec<AxOrdersWsMessage>> {
511        match resp {
512            AxWsOrderResponse::PlaceOrder(msg) => {
513                log::debug!("Place order response: rid={} oid={}", msg.rid, msg.res.oid);
514                let Some(order_info) = self.pending_orders.remove(&msg.rid) else {
515                    log::warn!("Ignoring unsolicited place order response: rid={}", msg.rid);
516                    return Some(vec![AxOrdersWsMessage::PlaceOrderResponse(msg)]);
517                };
518
519                let venue_order_id = match VenueOrderId::new_checked(&msg.res.oid) {
520                    Ok(venue_order_id) => venue_order_id,
521                    Err(e) => {
522                        log::warn!(
523                            "Invalid venue order ID in place response for {}: {e}",
524                            order_info.client_order_id,
525                        );
526                        return Some(vec![AxOrdersWsMessage::PlaceOrderResponse(msg)]);
527                    }
528                };
529
530                if let Some(mut metadata) =
531                    self.orders_metadata.get_mut(&order_info.client_order_id)
532                {
533                    if metadata
534                        .venue_order_id
535                        .is_none_or(|current| current == venue_order_id)
536                    {
537                        metadata.venue_order_id = Some(venue_order_id);
538                        self.venue_to_client_order_id
539                            .insert(venue_order_id, order_info.client_order_id);
540                    }
541                } else {
542                    log::debug!(
543                        "Order tracking already cleared before place response: {}",
544                        order_info.client_order_id,
545                    );
546                }
547
548                Some(vec![AxOrdersWsMessage::PlaceOrderResponse(msg)])
549            }
550            AxWsOrderResponse::CancelOrder(msg) => {
551                log::debug!(
552                    "Cancel order response: rid={} accepted={}",
553                    msg.rid,
554                    msg.res.cxl_rx
555                );
556                Some(vec![AxOrdersWsMessage::CancelOrderResponse(msg)])
557            }
558            AxWsOrderResponse::OpenOrders(msg) => {
559                log::debug!("Open orders response: {} orders", msg.res.orders.len());
560                Some(vec![AxOrdersWsMessage::OpenOrdersResponse(msg)])
561            }
562            AxWsOrderResponse::List(msg) => self.handle_login(epoch, &msg),
563        }
564    }
565
566    fn fail_login(&mut self, error: String) -> Vec<AxOrdersWsMessage> {
567        log::error!("{error}");
568        self.awaiting_login = false;
569        self.authenticated_epoch = None;
570        self.login_deadline = None;
571        self.session_failed = true;
572        self.auth_tracker.fail(error.clone());
573        vec![AxOrdersWsMessage::Error(AxWsError::new(error))]
574    }
575
576    fn handle_login(
577        &mut self,
578        epoch: u64,
579        msg: &AxWsListResponse,
580    ) -> Option<Vec<AxOrdersWsMessage>> {
581        if self.session_failed {
582            log::warn!("Ignoring orders WebSocket login after session failure");
583            return None;
584        }
585
586        if self.cancel_on_disconnect.is_some()
587            && self
588                .inner
589                .as_ref()
590                .is_some_and(|inner| inner.connection_epoch() != epoch)
591        {
592            log::warn!("Ignoring stale orders WebSocket login: epoch={epoch}");
593            return None;
594        }
595
596        let order_count = msg.res.o.as_ref().map_or(0, |o| o.len());
597        log::debug!(
598            "List subscription response: rid={} li={} orders={}",
599            msg.rid,
600            msg.res.li,
601            order_count
602        );
603
604        let expected = self.cancel_on_disconnect?;
605        let acknowledged = msg.res.cod;
606        let accepted = if expected {
607            acknowledged == Some(true)
608        } else {
609            acknowledged != Some(true)
610        };
611
612        if !accepted {
613            let error = format!(
614                "AX cancel-on-disconnect acknowledgment mismatch: expected {expected}, was {acknowledged:?}"
615            );
616            log::error!("{error}");
617            return Some(self.fail_login(error));
618        }
619
620        self.awaiting_login = false;
621        self.authenticated_epoch = Some(epoch);
622        self.login_deadline = None;
623        self.has_authenticated_session = true;
624        self.auth_tracker.succeed();
625        Some(vec![AxOrdersWsMessage::Authenticated])
626    }
627
628    fn handle_event(&self, event: AxWsOrderEvent) -> Option<Vec<AxOrdersWsMessage>> {
629        if matches!(event, AxWsOrderEvent::Heartbeat) {
630            log::trace!("Received heartbeat");
631            return None;
632        }
633        Some(vec![AxOrdersWsMessage::Event(Box::new(event))])
634    }
635}
636
637#[cfg(test)]
638mod tests {
639    use std::sync::{Arc, atomic::AtomicBool};
640
641    use dashmap::DashMap;
642    use futures_util::StreamExt;
643    use nautilus_core::time::get_atomic_clock_realtime;
644    use nautilus_model::{
645        identifiers::{AccountId, InstrumentId, StrategyId, TraderId},
646        types::{Currency, Money},
647    };
648    use nautilus_network::websocket::{AuthTracker, WebSocketConfig, auth::AuthState};
649    use rstest::rstest;
650    use rust_decimal::Decimal;
651    use ustr::Ustr;
652
653    use super::*;
654    use crate::{
655        common::enums::{AxOrderSide, AxTimeInForce},
656        execution::create_order_filled,
657        websocket::{
658            messages::{
659                AxWsListResponse, AxWsListResult, AxWsOrderError, AxWsOrderErrorResponse,
660                AxWsOrderFilled, AxWsPlaceOrderResponse, AxWsPlaceOrderResult,
661            },
662            orders::OrdersCaches,
663        },
664    };
665
666    fn test_handler(cancel_on_disconnect: Option<bool>) -> AxOrdersWsFeedHandler {
667        let (_cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
668        let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
669        AxOrdersWsFeedHandler::new(
670            Arc::new(AtomicBool::new(false)),
671            cmd_rx,
672            raw_rx,
673            AuthTracker::default(),
674            cancel_on_disconnect,
675            Arc::new(DashMap::new()),
676            Arc::new(DashMap::new()),
677        )
678    }
679
680    fn login(cod: Option<bool>) -> AxWsListResponse {
681        AxWsListResponse {
682            rid: 0,
683            res: AxWsListResult {
684                li: "test-user".to_string(),
685                o: Some(vec![]),
686                cod,
687                chb: None,
688            },
689        }
690    }
691
692    async fn connected_client() -> (WebSocketClient, tokio::task::JoinHandle<()>) {
693        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
694        let addr = listener.local_addr().unwrap();
695        let server = tokio::spawn(async move {
696            let (socket, _) = listener.accept().await.unwrap();
697            let mut socket = tokio_tungstenite::accept_async(socket).await.unwrap();
698            while socket.next().await.is_some() {}
699        });
700
701        let config = WebSocketConfig::builder()
702            .url(format!("ws://{addr}"))
703            .build()
704            .unwrap();
705        let (_, client) = WebSocketClient::stream_builder()
706            .config(config)
707            .connect()
708            .await
709            .unwrap();
710        (client, server)
711    }
712
713    #[tokio::test]
714    async fn test_order_writes_wait_for_login_after_reconnect() {
715        let mut handler = test_handler(Some(true));
716
717        let request = AxWsGetOpenOrders {
718            rid: 72,
719            t: AxOrderRequestType::GetOpenOrders,
720        };
721
722        let error = handler.send_json(&request).await.unwrap_err();
723        assert!(matches!(
724            error,
725            OrderSendError::NotSent(reason) if reason == "Orders WebSocket session login pending"
726        ));
727
728        let messages = handler
729            .handle_response(0, AxWsOrderResponse::List(login(Some(true))))
730            .unwrap();
731        assert!(matches!(
732            messages.as_slice(),
733            [AxOrdersWsMessage::Authenticated]
734        ));
735        assert!(handler.auth_tracker.is_authenticated());
736
737        handler.authenticated_epoch = Some(1);
738        let messages = handler
739            .parse_raw_message(0, Message::Text(nautilus_network::RECONNECTED.into()))
740            .unwrap();
741        assert!(matches!(
742            messages.as_slice(),
743            [AxOrdersWsMessage::Reconnected]
744        ));
745        assert_eq!(
746            handler.auth_tracker.auth_state(),
747            AuthState::Unauthenticated
748        );
749
750        let error = handler.send_json(&request).await.unwrap_err();
751        assert!(matches!(
752            error,
753            OrderSendError::NotSent(reason) if reason == "Orders WebSocket session login pending"
754        ));
755
756        let messages = handler
757            .handle_response(0, AxWsOrderResponse::List(login(Some(true))))
758            .unwrap();
759        assert!(matches!(
760            messages.as_slice(),
761            [AxOrdersWsMessage::Authenticated]
762        ));
763        let error = handler.send_json(&request).await.unwrap_err();
764        assert!(matches!(
765            error,
766            OrderSendError::NotSent(reason) if reason == "No WebSocket client available"
767        ));
768    }
769
770    #[tokio::test]
771    async fn test_early_login_is_preserved_and_stale_epoch_is_rejected() {
772        let (inner, server) = connected_client().await;
773        let mut handler = test_handler(Some(true));
774        handler.inner = Some(inner);
775
776        let request = AxWsGetOpenOrders {
777            rid: 72,
778            t: AxOrderRequestType::GetOpenOrders,
779        };
780
781        handler.handle_response(0, AxWsOrderResponse::List(login(Some(true))));
782        tokio::time::timeout(Duration::from_secs(1), handler.send_json(&request))
783            .await
784            .unwrap()
785            .unwrap();
786        handler.parse_raw_message(0, Message::Text(nautilus_network::RECONNECTED.into()));
787
788        assert!(!handler.awaiting_login);
789        assert_eq!(handler.authenticated_epoch, Some(0));
790        assert_eq!(handler.login_deadline, None);
791        assert!(handler.auth_tracker.is_authenticated());
792
793        handler.authenticated_epoch = Some(1);
794        let error = handler.send_json(&request).await.unwrap_err();
795        assert!(matches!(
796            error,
797            OrderSendError::Ambiguous(reason) if reason == "Orders WebSocket session changed before login"
798        ));
799
800        handler.inner.take().unwrap().disconnect().await;
801        server.abort();
802    }
803
804    #[tokio::test]
805    async fn test_stale_login_does_not_authenticate_current_connection() {
806        let (inner, server) = connected_client().await;
807        let mut handler = test_handler(Some(true));
808        handler.inner = Some(inner);
809
810        let messages = handler.handle_response(1, AxWsOrderResponse::List(login(Some(true))));
811
812        assert!(messages.is_none());
813        assert_eq!(handler.authenticated_epoch, None);
814        assert!(handler.awaiting_login);
815        assert!(!handler.auth_tracker.is_authenticated());
816        assert!(handler.login_deadline.is_some());
817
818        handler.handle_response(0, AxWsOrderResponse::List(login(Some(true))));
819        assert_eq!(handler.authenticated_epoch, Some(0));
820        assert!(handler.auth_tracker.is_authenticated());
821        handler.inner.take().unwrap().disconnect().await;
822        server.abort();
823    }
824
825    #[tokio::test]
826    async fn test_set_client_is_processed_before_initial_login() {
827        let (inner, server) = connected_client().await;
828        let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
829        let (raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
830
831        let mut handler = AxOrdersWsFeedHandler::new(
832            Arc::new(AtomicBool::new(false)),
833            cmd_rx,
834            raw_rx,
835            AuthTracker::default(),
836            Some(true),
837            Arc::new(DashMap::new()),
838            Arc::new(DashMap::new()),
839        );
840        cmd_tx.send(HandlerCommand::SetClient(inner)).unwrap();
841        raw_tx
842            .send((
843                0,
844                Message::Text(r#"{"rid":0,"res":{"li":"test-user","o":[],"cod":true}}"#.into()),
845            ))
846            .unwrap();
847
848        let message = handler.next().await.unwrap();
849
850        assert!(matches!(message, AxOrdersWsMessage::Authenticated));
851        assert_eq!(handler.authenticated_epoch, Some(0));
852        assert!(handler.auth_tracker.is_authenticated());
853        handler.inner.take().unwrap().disconnect().await;
854        server.abort();
855    }
856
857    #[tokio::test]
858    async fn test_order_writes_stop_after_cancel_on_disconnect_mismatch() {
859        let mut handler = test_handler(Some(true));
860
861        let request = AxWsGetOpenOrders {
862            rid: 72,
863            t: AxOrderRequestType::GetOpenOrders,
864        };
865
866        let messages = handler
867            .handle_response(0, AxWsOrderResponse::List(login(Some(false))))
868            .unwrap();
869
870        assert!(matches!(messages.as_slice(), [AxOrdersWsMessage::Error(_)]));
871        assert!(handler.session_failed);
872        assert!(!handler.auth_tracker.is_authenticated());
873        let error = handler.send_json(&request).await.unwrap_err();
874        assert!(matches!(
875            error,
876            OrderSendError::NotSent(reason) if reason == "Orders WebSocket session authentication failed"
877        ));
878    }
879
880    #[tokio::test]
881    async fn test_failed_session_drains_buffered_commands_before_close() {
882        let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
883        let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
884
885        let mut handler = AxOrdersWsFeedHandler::new(
886            Arc::new(AtomicBool::new(false)),
887            cmd_rx,
888            raw_rx,
889            AuthTracker::default(),
890            Some(true),
891            Arc::new(DashMap::new()),
892            Arc::new(DashMap::new()),
893        );
894        handler.session_failed = true;
895        handler.awaiting_login = false;
896        let client_order_id = ClientOrderId::from("CID-SHUTDOWN");
897        let command_id = UUID4::new();
898
899        let order_info = WsOrderInfo {
900            client_order_id,
901            symbol: Ustr::from("EURUSD-PERP"),
902            cid: 42,
903        };
904
905        cmd_tx
906            .send(HandlerCommand::PlaceOrder {
907                request_id: 1,
908                order: AxWsPlaceOrder {
909                    rid: 1,
910                    t: AxOrderRequestType::PlaceOrder,
911                    s: order_info.symbol,
912                    d: AxOrderSide::Buy,
913                    q: 1,
914                    p: Decimal::from(100),
915                    tif: AxTimeInForce::Gtc,
916                    po: true,
917                    st: None,
918                    tag: None,
919                    cid: Some(order_info.cid),
920                },
921                order_info,
922            })
923            .unwrap();
924
925        cmd_tx
926            .send(HandlerCommand::CancelOrder {
927                request_id: 2,
928                order_id: "OID-SHUTDOWN".to_string(),
929                client_order_id,
930                command_id: Some(command_id),
931            })
932            .unwrap();
933
934        let place = handler.next().await.unwrap();
935        assert!(matches!(
936            place,
937            AxOrdersWsMessage::PlaceOrderError {
938                client_order_id: id,
939                reason,
940            } if id == client_order_id && reason == "Orders WebSocket session authentication failed"
941        ));
942        let cancel = handler.next().await.unwrap();
943        assert!(matches!(
944            cancel,
945            AxOrdersWsMessage::CancelOrderError {
946                client_order_id: id,
947                reason,
948                command_id: actual_command_id,
949            } if id == client_order_id
950                && reason == "Orders WebSocket session authentication failed"
951                && actual_command_id == Some(command_id)
952        ));
953        assert!(
954            cmd_tx
955                .send(HandlerCommand::GetOpenOrders { request_id: 3 })
956                .is_err()
957        );
958        assert!(handler.next().await.is_none());
959        assert!(handler.pending_orders.is_empty());
960    }
961
962    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
963    async fn test_failed_session_drains_concurrent_commands() {
964        let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
965        let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
966
967        let mut handler = AxOrdersWsFeedHandler::new(
968            Arc::new(AtomicBool::new(false)),
969            cmd_rx,
970            raw_rx,
971            AuthTracker::default(),
972            Some(true),
973            Arc::new(DashMap::new()),
974            Arc::new(DashMap::new()),
975        );
976        handler.session_failed = true;
977        handler.awaiting_login = false;
978        let client_order_id = ClientOrderId::from("CID-CONCURRENT-SHUTDOWN");
979
980        let order_info = WsOrderInfo {
981            client_order_id,
982            symbol: Ustr::from("EURUSD-PERP"),
983            cid: 42,
984        };
985
986        let command_count = 32;
987        let barrier = Arc::new(tokio::sync::Barrier::new(command_count + 1));
988        let mut senders = Vec::with_capacity(command_count);
989
990        for index in 0..command_count {
991            let cmd_tx = cmd_tx.clone();
992            let barrier = barrier.clone();
993            let order_info = order_info.clone();
994
995            senders.push(tokio::spawn(async move {
996                barrier.wait().await;
997                cmd_tx
998                    .send(HandlerCommand::PlaceOrder {
999                        request_id: index as i64,
1000                        order: AxWsPlaceOrder {
1001                            rid: index as i64,
1002                            t: AxOrderRequestType::PlaceOrder,
1003                            s: order_info.symbol,
1004                            d: AxOrderSide::Buy,
1005                            q: 1,
1006                            p: Decimal::from(100),
1007                            tif: AxTimeInForce::Gtc,
1008                            po: true,
1009                            st: None,
1010                            tag: None,
1011                            cid: Some(order_info.cid),
1012                        },
1013                        order_info,
1014                    })
1015                    .is_ok()
1016            }));
1017        }
1018
1019        barrier.wait().await;
1020        let mut rejected = 0;
1021
1022        while let Some(message) = handler.next().await {
1023            assert!(matches!(
1024                message,
1025                AxOrdersWsMessage::PlaceOrderError {
1026                    client_order_id: id,
1027                    ..
1028                } if id == client_order_id
1029            ));
1030            rejected += 1;
1031        }
1032
1033        let accepted = futures_util::future::join_all(senders)
1034            .await
1035            .into_iter()
1036            .filter(|result| matches!(result, Ok(true)))
1037            .count();
1038
1039        assert_eq!(rejected, accepted);
1040        assert!(handler.pending_orders.is_empty());
1041    }
1042
1043    #[tokio::test]
1044    async fn test_late_login_does_not_authenticate_failed_session() {
1045        let mut handler = test_handler(Some(true));
1046        handler.session_failed = true;
1047        handler.auth_tracker.fail("login failed");
1048
1049        let messages = handler.handle_response(0, AxWsOrderResponse::List(login(Some(true))));
1050
1051        assert!(messages.is_none());
1052        assert!(handler.session_failed);
1053        assert!(!handler.auth_tracker.is_authenticated());
1054    }
1055
1056    #[tokio::test]
1057    async fn test_gate_rejections_carry_client_order_id() {
1058        let mut handler = test_handler(Some(true));
1059        let client_order_id = ClientOrderId::from("CID-GATE");
1060        let command_id = UUID4::new();
1061
1062        let order_info = WsOrderInfo {
1063            client_order_id,
1064            symbol: Ustr::from("EURUSD-PERP"),
1065            cid: 42,
1066        };
1067
1068        handler
1069            .handle_command(HandlerCommand::PlaceOrder {
1070                request_id: 1,
1071                order: AxWsPlaceOrder {
1072                    rid: 1,
1073                    t: AxOrderRequestType::PlaceOrder,
1074                    s: order_info.symbol,
1075                    d: AxOrderSide::Buy,
1076                    q: 1,
1077                    p: Decimal::from(100),
1078                    tif: AxTimeInForce::Gtc,
1079                    po: true,
1080                    st: None,
1081                    tag: None,
1082                    cid: Some(order_info.cid),
1083                },
1084                order_info,
1085            })
1086            .await;
1087
1088        handler
1089            .handle_command(HandlerCommand::CancelOrder {
1090                request_id: 2,
1091                order_id: "OID-GATE".to_string(),
1092                client_order_id,
1093                command_id: Some(command_id),
1094            })
1095            .await;
1096
1097        let place = handler.message_queue.pop_front().unwrap();
1098        assert!(matches!(
1099            place,
1100            AxOrdersWsMessage::PlaceOrderError {
1101                client_order_id: id,
1102                reason,
1103            } if id == client_order_id && reason == "Orders WebSocket session login pending"
1104        ));
1105        let cancel = handler.message_queue.pop_front().unwrap();
1106        assert!(matches!(
1107            cancel,
1108            AxOrdersWsMessage::CancelOrderError {
1109                client_order_id: id,
1110                reason,
1111                command_id: actual_command_id,
1112            } if id == client_order_id
1113                && reason == "Orders WebSocket session login pending"
1114                && actual_command_id == Some(command_id)
1115        ));
1116    }
1117
1118    #[tokio::test]
1119    async fn test_login_timeout_emits_error_before_close() {
1120        let (_cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();
1121        let (_raw_tx, raw_rx) = tokio::sync::mpsc::unbounded_channel();
1122
1123        let mut handler = AxOrdersWsFeedHandler::new(
1124            Arc::new(AtomicBool::new(false)),
1125            cmd_rx,
1126            raw_rx,
1127            AuthTracker::default(),
1128            Some(true),
1129            Arc::new(DashMap::new()),
1130            Arc::new(DashMap::new()),
1131        );
1132        handler.login_deadline = Some(tokio::time::Instant::now());
1133
1134        let message = handler.next().await.unwrap();
1135        assert!(matches!(
1136            message,
1137            AxOrdersWsMessage::Error(AxWsError { message, .. }) if message == "Orders WebSocket login timed out"
1138        ));
1139        assert!(handler.next().await.is_none());
1140    }
1141
1142    #[rstest]
1143    fn test_late_place_order_response_does_not_restore_cleared_tracking() {
1144        let mut handler = test_handler(None);
1145        let request_id = 12;
1146        let client_order_id = ClientOrderId::from("CID-12");
1147        handler.pending_orders.insert(
1148            request_id,
1149            WsOrderInfo {
1150                client_order_id,
1151                symbol: Ustr::from("EURUSD-PERP"),
1152                cid: 1012,
1153            },
1154        );
1155
1156        let response = AxWsOrderResponse::PlaceOrder(AxWsPlaceOrderResponse {
1157            rid: request_id,
1158            res: AxWsPlaceOrderResult {
1159                oid: "OID-12".to_string(),
1160            },
1161        });
1162
1163        let messages = handler.handle_response(0, response).unwrap();
1164
1165        assert_eq!(messages.len(), 1);
1166        assert!(handler.pending_orders.get(&request_id).is_none());
1167        assert!(!handler.orders_metadata.contains_key(&client_order_id));
1168        assert!(handler.venue_to_client_order_id.is_empty());
1169    }
1170
1171    #[rstest]
1172    fn test_place_order_error_preserves_cid_for_reconciliation() {
1173        let mut handler = test_handler(None);
1174        let request_id = 13;
1175        let cid = 1013;
1176        let client_order_id = ClientOrderId::from("CID-13");
1177        handler
1178            .orders_metadata
1179            .insert(client_order_id, test_order_metadata(client_order_id));
1180        handler.pending_orders.insert(
1181            request_id,
1182            WsOrderInfo {
1183                client_order_id,
1184                symbol: Ustr::from("EURUSD-PERP"),
1185                cid,
1186            },
1187        );
1188
1189        let messages = handler
1190            .handle_raw_message(
1191                0,
1192                AxOrdersWsFrame::Error(AxWsOrderErrorResponse {
1193                    rid: request_id,
1194                    err: AxWsOrderError {
1195                        code: Some(400),
1196                        msg: Some("invalid order".to_string()),
1197                    },
1198                }),
1199            )
1200            .unwrap();
1201
1202        assert_eq!(messages.len(), 1);
1203        assert_eq!(
1204            handler
1205                .pending_orders
1206                .get(&request_id)
1207                .unwrap()
1208                .client_order_id,
1209            client_order_id,
1210        );
1211        assert!(handler.orders_metadata.contains_key(&client_order_id));
1212        handler.handle_response(
1213            0,
1214            AxWsOrderResponse::PlaceOrder(AxWsPlaceOrderResponse {
1215                rid: request_id,
1216                res: AxWsPlaceOrderResult {
1217                    oid: "OID-13".to_string(),
1218                },
1219            }),
1220        );
1221
1222        assert_eq!(
1223            handler
1224                .orders_metadata
1225                .get(&client_order_id)
1226                .unwrap()
1227                .venue_order_id,
1228            Some(VenueOrderId::from("OID-13"))
1229        );
1230        assert_eq!(
1231            *handler
1232                .venue_to_client_order_id
1233                .get(&VenueOrderId::from("OID-13"))
1234                .unwrap(),
1235            client_order_id
1236        );
1237    }
1238
1239    #[rstest]
1240    #[case::known_unsent(true, false)]
1241    #[case::ambiguous_request_error(false, true)]
1242    #[tokio::test]
1243    async fn test_place_error_tracking_depends_on_send_certainty(
1244        #[case] send_failure: bool,
1245        #[case] expect_pending: bool,
1246    ) {
1247        let mut handler = test_handler(None);
1248        let client_order_id = ClientOrderId::from("CID-UNCERTAIN");
1249        let request_id = 17;
1250        let cid = 1017;
1251        handler
1252            .orders_metadata
1253            .insert(client_order_id, test_order_metadata(client_order_id));
1254
1255        let order_info = WsOrderInfo {
1256            client_order_id,
1257            symbol: Ustr::from("EURUSD-PERP"),
1258            cid,
1259        };
1260
1261        if send_failure {
1262            handler
1263                .handle_command(HandlerCommand::PlaceOrder {
1264                    request_id,
1265                    order: AxWsPlaceOrder {
1266                        rid: request_id,
1267                        t: AxOrderRequestType::PlaceOrder,
1268                        s: order_info.symbol,
1269                        d: AxOrderSide::Buy,
1270                        q: 100,
1271                        p: Decimal::from(50000),
1272                        tif: AxTimeInForce::Gtc,
1273                        po: false,
1274                        st: None,
1275                        tag: None,
1276                        cid: Some(cid),
1277                    },
1278                    order_info,
1279                })
1280                .await;
1281
1282            assert!(matches!(
1283                handler.message_queue.pop_front(),
1284                Some(AxOrdersWsMessage::PlaceOrderError { .. })
1285            ));
1286        } else {
1287            handler.pending_orders.insert(request_id, order_info);
1288            handler.handle_raw_message(
1289                0,
1290                AxOrdersWsFrame::Error(AxWsOrderErrorResponse {
1291                    rid: request_id,
1292                    err: AxWsOrderError {
1293                        code: Some(500),
1294                        msg: Some("unresolved request".to_string()),
1295                    },
1296                }),
1297            );
1298        }
1299
1300        if !expect_pending {
1301            assert!(handler.pending_orders.get(&request_id).is_none());
1302            return;
1303        }
1304
1305        let caches = OrdersCaches {
1306            orders_metadata: handler.orders_metadata.clone(),
1307            venue_to_client_id: handler.venue_to_client_order_id.clone(),
1308            cid_to_client_order_id: Arc::new(DashMap::new()),
1309            ..OrdersCaches::default()
1310        };
1311
1312        caches.cid_to_client_order_id.insert(cid, client_order_id);
1313        let mut fill: AxWsOrderFilled =
1314            serde_json::from_str(include_str!("../../../test_data/ws_order_filled.json")).unwrap();
1315        fill.o.cid = Some(cid);
1316        let event = create_order_filled(
1317            &fill.o,
1318            &fill.xs,
1319            fill.ts,
1320            fill.tn,
1321            &caches,
1322            AccountId::from("AX-001"),
1323            Money::from("1.23 USD"),
1324            get_atomic_clock_realtime(),
1325        )
1326        .expect("fill after uncertain error must remain tracked");
1327
1328        assert_eq!(event.client_order_id, client_order_id);
1329        assert_eq!(event.trader_id, TraderId::from("TRADER-001"));
1330        assert_eq!(event.strategy_id, StrategyId::from("S-001"));
1331        assert_eq!(event.instrument_id, InstrumentId::from("EURUSD-PERP.AX"));
1332        assert_eq!(event.last_qty.as_decimal(), Decimal::from(100));
1333        assert_eq!(event.last_px.as_decimal(), Decimal::from(50000));
1334        assert_eq!(event.commission, Some(Money::from("1.23 USD")));
1335        assert_eq!(
1336            handler
1337                .pending_orders
1338                .get(&request_id)
1339                .unwrap()
1340                .client_order_id,
1341            client_order_id
1342        );
1343        assert_eq!(
1344            *caches.cid_to_client_order_id.get(&cid).unwrap(),
1345            client_order_id
1346        );
1347    }
1348
1349    #[rstest]
1350    fn test_late_place_response_preserves_replacement_binding() {
1351        let mut handler = test_handler(None);
1352        let client_order_id = ClientOrderId::from("CID-REPLACED");
1353        let replacement_id = VenueOrderId::from("OID-CHILD");
1354        let mut metadata = test_order_metadata(client_order_id);
1355        metadata.venue_order_id = Some(replacement_id);
1356        handler.orders_metadata.insert(client_order_id, metadata);
1357        handler
1358            .venue_to_client_order_id
1359            .insert(replacement_id, client_order_id);
1360        handler.pending_orders.insert(
1361            18,
1362            WsOrderInfo {
1363                client_order_id,
1364                symbol: Ustr::from("EURUSD-PERP"),
1365                cid: 1018,
1366            },
1367        );
1368
1369        handler.handle_response(
1370            0,
1371            AxWsOrderResponse::PlaceOrder(AxWsPlaceOrderResponse {
1372                rid: 18,
1373                res: AxWsPlaceOrderResult {
1374                    oid: "OID-PARENT".to_string(),
1375                },
1376            }),
1377        );
1378
1379        assert_eq!(
1380            handler
1381                .orders_metadata
1382                .get(&client_order_id)
1383                .unwrap()
1384                .venue_order_id,
1385            Some(replacement_id)
1386        );
1387        assert_eq!(
1388            *handler
1389                .venue_to_client_order_id
1390                .get(&replacement_id)
1391                .unwrap(),
1392            client_order_id
1393        );
1394        assert_eq!(handler.venue_to_client_order_id.len(), 1);
1395    }
1396
1397    #[rstest]
1398    fn test_handle_event_suppresses_heartbeat() {
1399        let handler = test_handler(None);
1400
1401        let event = AxWsOrderEvent::Heartbeat;
1402        let result = handler.handle_event(event);
1403        assert!(result.is_none());
1404    }
1405
1406    fn test_order_metadata(client_order_id: ClientOrderId) -> OrderMetadata {
1407        OrderMetadata {
1408            trader_id: TraderId::from("TRADER-001"),
1409            strategy_id: StrategyId::from("S-001"),
1410            instrument_id: InstrumentId::from("EURUSD-PERP.AX"),
1411            client_order_id,
1412            order_init: None,
1413            is_accepted: false,
1414            venue_order_id: None,
1415            ts_init: 0.into(),
1416            size_precision: 0,
1417            price_precision: 2,
1418            quote_currency: Currency::USD(),
1419        }
1420    }
1421}