nautilus_hyperliquid/websocket/

client.rs

// -------------------------------------------------------------------------------------------------
//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
//  https://nautechsystems.io
//
//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
//  You may not use this file except in compliance with the License.
//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
// -------------------------------------------------------------------------------------------------

use std::{
    str::FromStr,
    sync::{
        Arc,
        atomic::{AtomicBool, AtomicU8, AtomicU64, Ordering},
    },
    time::Duration,
};

use ahash::{AHashMap, AHashSet};
use anyhow::Context;
use arc_swap::ArcSwap;
use dashmap::DashMap;
use nautilus_common::cache::{InstrumentLookupError, fifo::FifoCacheMap};
#[cfg(test)]
use nautilus_common::live::get_runtime;
#[cfg(test)]
use nautilus_core::string::secret::REDACTED;
use nautilus_core::{AtomicMap, string::secret::SecretString};
use nautilus_live::{
    SocketControl,
    book::snapshot::SnapshotGate,
    task::{SharedTaskSlot, TaskGroupGuard, TaskJoinOutcome},
};
use nautilus_model::{
    data::BarType,
    enums::{OrderSide, OrderType, TimeInForce},
    identifiers::{AccountId, ClientOrderId, InstrumentId, VenueOrderId},
    instruments::{Instrument, InstrumentAny},
    orders::{Order, OrderAny},
    reports::OrderStatusReport,
    types::{Price, Quantity},
};
use nautilus_network::{
    ConnectionUrl, SocketStateSink,
    http::create_standard_nautilus_headers,
    mode::ConnectionMode,
    websocket::{
        AuthTracker, SubscriptionState, TransportBackend, WebSocketClient, WebSocketConfig,
        channel_message_handler,
    },
};
use parking_lot::Mutex;
use rust_decimal::Decimal;
use serde::Deserialize;
use tokio_util::sync::CancellationToken;
use ustr::Ustr;

use crate::{
    common::{
        consts::{HEARTBEAT_INTERVAL, HTTP_TIMEOUT, ws_url},
        enums::{HyperliquidBarInterval, HyperliquidEnvironment},
        parse::{
            bar_type_to_interval, clamp_price_to_precision, derive_limit_from_trigger,
            determine_order_list_grouping, extract_error_message, extract_inner_error,
            extract_inner_errors, normalize_or_validate_wire_price,
            order_to_hyperliquid_request_with_optional_decimals, round_to_sig_figs,
            time_in_force_to_hyperliquid_tif,
        },
    },
    http::{
        client::HyperliquidHttpClient,
        error::{Error as HyperliquidError, Result as HyperliquidResult},
        models::{
            HyperliquidExchangeAction, HyperliquidExchangeCancelByCloidRequest,
            HyperliquidExchangeCancelOrderRequest, HyperliquidExchangeGrouping,
            HyperliquidExchangeLimitParams, HyperliquidExchangeModifyOrderRequest,
            HyperliquidExchangeModifyTarget, HyperliquidExchangeOrderKind,
            HyperliquidExchangePlaceOrderRequest, HyperliquidExchangeResponse,
            HyperliquidExchangeTif, HyperliquidExchangeTpSl, HyperliquidExchangeTriggerParams,
            RESPONSE_STATUS_OK,
        },
        rate_limits::exec_action_weight,
    },
    websocket::{
        book::{
            BookStreamOptions, BookStreamRegistration, BookStreamRegistry, BookStreamRelease,
            BookStreamUse,
        },
        enums::HyperliquidWsChannel,
        error::HyperliquidWsError,
        handler::{FeedHandler, HandlerCommand},
        messages::{
            NautilusWsMessage, PostRequest, PostResponse, PostResponsePayload, SubscriptionRequest,
        },
        post::{PostIds, PostRouter},
        rate_limits::{WebSocketRateLimits, shared_websocket_limits},
        trades::{TradeStreamRegistry, TradeStreamUse},
    },
};

const RESPONSE_STATUS_ERR: &str = "err";

static NEXT_WEBSOCKET_CLIENT_ID: AtomicU64 = AtomicU64::new(1);

/// FIFO bound on the cloid -> `ClientOrderId` resolution cache so missed
/// evictions self-recover (see GH-3972 cancel-replace drain path).
pub(super) const CLOID_CACHE_CAPACITY: usize = 10_000;

/// Shared cloid -> `ClientOrderId` cache used by the WS handler.
pub(super) type CloidCache = Arc<Mutex<FifoCacheMap<Ustr, ClientOrderId, CLOID_CACHE_CAPACITY>>>;

/// Represents the different data types available from asset context subscriptions.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(super) enum AssetContextDataType {
    MarkPrice,
    IndexPrice,
    FundingRate,
    OpenInterest,
}

/// Hyperliquid WebSocket client.
///
/// Orchestrates WebSocket connection and subscriptions using a command-based architecture,
/// where the inner FeedHandler owns the WebSocketClient and handles all I/O.
#[derive(Debug)]
pub struct HyperliquidWebSocketClient {
    url: ConnectionUrl,
    connection_mode: Arc<ArcSwap<AtomicU8>>,
    signal: Arc<AtomicBool>,
    cmd_tx: Arc<tokio::sync::RwLock<tokio::sync::mpsc::UnboundedSender<HandlerCommand>>>,
    out_rx: Option<tokio::sync::mpsc::UnboundedReceiver<NautilusWsMessage>>,
    auth_tracker: AuthTracker,
    subscriptions: SubscriptionState,
    book_streams: BookStreamRegistry,
    trade_streams: TradeStreamRegistry,
    trade_stream_lock: Arc<Mutex<()>>,
    quote_streams: Arc<DashMap<Ustr, ()>>,
    instruments: Arc<AtomicMap<Ustr, InstrumentAny>>,
    cache_tx: Arc<Mutex<tokio::sync::mpsc::UnboundedSender<HandlerCommand>>>,
    bar_types: Arc<AtomicMap<String, BarType>>,
    asset_context_subs: Arc<DashMap<Ustr, AHashSet<AssetContextDataType>>>,
    all_dex_asset_ctxs_instrument_ids: Arc<AtomicMap<Ustr, Vec<Option<InstrumentId>>>>,
    cloid_cache: CloidCache,
    post_router: Arc<PostRouter>,
    post_ids: Arc<PostIds>,
    rate_limits: Arc<WebSocketRateLimits>,
    client_id: u64,
    connection_permit: Arc<Mutex<Option<tokio::sync::OwnedSemaphorePermit>>>,
    post_timeout: Duration,
    task_handle: Arc<SharedTaskSlot<()>>,
    connect_lock: Arc<tokio::sync::Mutex<()>>,
    account_id: Option<AccountId>,
    transport_backend: TransportBackend,
    proxy_url: Option<SecretString>,
    socket_sink: Option<SocketStateSink>,
    socket_control: Option<SocketControl>,
}

impl Clone for HyperliquidWebSocketClient {
    fn clone(&self) -> Self {
        Self {
            url: self.url.clone(),
            connection_mode: Arc::clone(&self.connection_mode),
            signal: Arc::clone(&self.signal),
            cmd_tx: Arc::clone(&self.cmd_tx),
            out_rx: None,
            auth_tracker: self.auth_tracker.clone(),
            subscriptions: self.subscriptions.clone(),
            book_streams: self.book_streams.clone(),
            trade_streams: self.trade_streams.clone(),
            trade_stream_lock: Arc::clone(&self.trade_stream_lock),
            quote_streams: Arc::clone(&self.quote_streams),
            instruments: Arc::clone(&self.instruments),
            cache_tx: Arc::clone(&self.cache_tx),
            bar_types: Arc::clone(&self.bar_types),
            asset_context_subs: Arc::clone(&self.asset_context_subs),
            all_dex_asset_ctxs_instrument_ids: Arc::clone(&self.all_dex_asset_ctxs_instrument_ids),
            cloid_cache: Arc::clone(&self.cloid_cache),
            post_router: Arc::clone(&self.post_router),
            post_ids: Arc::clone(&self.post_ids),
            rate_limits: Arc::clone(&self.rate_limits),
            client_id: self.client_id,
            connection_permit: Arc::clone(&self.connection_permit),
            post_timeout: self.post_timeout,
            task_handle: Arc::clone(&self.task_handle),
            connect_lock: Arc::clone(&self.connect_lock),
            account_id: self.account_id,
            transport_backend: self.transport_backend,
            proxy_url: self.proxy_url.clone(),
            socket_sink: self.socket_sink.clone(),
            socket_control: self.socket_control.clone(),
        }
    }
}

impl HyperliquidWebSocketClient {
    /// Creates a new Hyperliquid WebSocket client without connecting.
    ///
    /// If `url` is `None`, the appropriate URL will be determined from the `environment`:
    /// - `Mainnet`: `wss://api.hyperliquid.xyz/ws`
    /// - `Testnet`: `wss://api.hyperliquid-testnet.xyz/ws`
    ///
    /// The connection will be established when `connect()` is called.
    pub fn new(
        url: Option<String>,
        environment: HyperliquidEnvironment,
        account_id: Option<AccountId>,
        transport_backend: TransportBackend,
        proxy_url: Option<String>,
    ) -> Self {
        let url = url.unwrap_or_else(|| ws_url(environment).to_string());
        let rate_limits = shared_websocket_limits(environment, &url, proxy_url.as_deref());
        let connection_mode = Arc::new(ArcSwap::new(Arc::new(AtomicU8::new(
            ConnectionMode::Closed as u8,
        ))));
        let (cmd_tx, _) = tokio::sync::mpsc::unbounded_channel();

        Self {
            url: url.into(),
            connection_mode,
            signal: Arc::new(AtomicBool::new(false)),
            auth_tracker: AuthTracker::new(),
            subscriptions: SubscriptionState::new(':'),
            book_streams: BookStreamRegistry::default(),
            trade_streams: TradeStreamRegistry::default(),
            trade_stream_lock: Arc::new(Mutex::new(())),
            quote_streams: Arc::new(DashMap::new()),
            instruments: Arc::new(AtomicMap::new()),
            cache_tx: Arc::new(Mutex::new(cmd_tx.clone())),
            bar_types: Arc::new(AtomicMap::new()),
            asset_context_subs: Arc::new(DashMap::new()),
            all_dex_asset_ctxs_instrument_ids: Arc::new(AtomicMap::new()),
            cloid_cache: Arc::new(Mutex::new(FifoCacheMap::new())),
            post_router: PostRouter::with_inflight(Arc::clone(&rate_limits.post_slots)),
            post_ids: Arc::new(PostIds::new(1)),
            rate_limits,
            client_id: NEXT_WEBSOCKET_CLIENT_ID.fetch_add(1, Ordering::Relaxed),
            connection_permit: Arc::new(Mutex::new(None)),
            post_timeout: HTTP_TIMEOUT,
            cmd_tx: Arc::new(tokio::sync::RwLock::new(cmd_tx)),
            out_rx: None,
            task_handle: Arc::new(SharedTaskSlot::new()),
            connect_lock: Arc::new(tokio::sync::Mutex::new(())),
            account_id,
            transport_backend,
            proxy_url: proxy_url.map(SecretString::from),
            socket_sink: None,
            socket_control: None,
        }
    }

    /// Configures socket state reporting for the underlying transport.
    #[must_use]
    pub fn with_state_sink(mut self, state_sink: SocketStateSink) -> Self {
        self.socket_sink = Some(state_sink);
        self
    }

    /// Configures state reporting and reconnect control for the underlying transport.
    #[must_use]
    pub(crate) fn with_socket_control(mut self, control: SocketControl) -> Self {
        self.socket_control = Some(control);
        self
    }

    /// Establishes the WebSocket connection and waits for the message handler to initialize.
    pub async fn connect(&mut self) -> anyhow::Result<()> {
        let connect_lock = Arc::clone(&self.connect_lock);
        let _guard = connect_lock.lock().await;
        self.connect_locked().await
    }

    async fn connect_locked(&mut self) -> anyhow::Result<()> {
        if self.is_active() {
            log::warn!("WebSocket already connected");
            return Ok(());
        }

        if !self.task_handle.is_empty() {
            self.disconnect_locked().await?;
        }

        if self.connection_permit.lock().is_none() {
            let permit = Arc::clone(&self.rate_limits.connection_slots)
                .try_acquire_owned()
                .map_err(|_| {
                    anyhow::anyhow!(
                        "Hyperliquid allows at most {} WebSocket connections per route",
                        crate::common::consts::HYPERLIQUID_WS_CONNECTIONS_MAX,
                    )
                })?;
            *self.connection_permit.lock() = Some(permit);
        }

        // A fresh socket has no venue-side subscriptions; stale book stream
        // entries must not gate the venue subscribe for re-subscriptions
        self.book_streams.clear();

        let (message_handler, raw_rx) = channel_message_handler();
        let headers = create_standard_nautilus_headers();

        let cfg = WebSocketConfig {
            url: self.url.expose().to_owned(),
            headers,
            heartbeat_interval_secs: None,
            heartbeat_payload: None,
            connect_timeout_ms: Some(15_000),
            reconnect_delay_initial_ms: Some(250),
            reconnect_delay_max_ms: Some(5_000),
            reconnect_backoff_factor: Some(2.0),
            reconnect_jitter_ms: Some(200),
            reconnect_max_attempts: None,
            heartbeat_timeout_secs: Some(HEARTBEAT_INTERVAL.as_secs() * 3),
            idle_timeout_ms: None,
            writer_capacity: None,
            backend: self.transport_backend,
            proxy_url: self
                .proxy_url
                .as_ref()
                .map(|value| value.expose_secret().to_owned()),
            max_message_size_bytes: None,
            max_frame_size_bytes: None,
        };
        let connection_rate_keys: Arc<[Ustr]> = Arc::from([self.rate_limits.connection_key()]);
        let client_result = WebSocketClient::builder()
            .config(cfg)
            .message_handler(message_handler)
            .rate_limiter(Arc::clone(&self.rate_limits.messages))
            .connection_rate_limiter(Arc::clone(&self.rate_limits.connections))
            .connection_rate_keys(connection_rate_keys)
            .maybe_state_sink(
                self.socket_control
                    .as_ref()
                    .map(SocketControl::sink)
                    .or_else(|| self.socket_sink.clone()),
            )
            .connect()
            .await;
        let client = match client_result {
            Ok(client) => client,
            Err(e) => {
                self.connection_permit.lock().take();
                return Err(e.into());
            }
        };

        if let Some(control) = &self.socket_control {
            let handle = client.reconnect_handle();
            control.register(move || handle.request_reconnect());
        }

        // Create channels for handler communication
        let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel::<HandlerCommand>();
        let (out_tx, out_rx) = tokio::sync::mpsc::unbounded_channel::<NautilusWsMessage>();

        self.out_rx = Some(out_rx);
        let connection_mode = client.connection_mode_atomic();
        let (initialized_tx, initialized_rx) = tokio::sync::oneshot::channel();

        if let Err(e) = cmd_tx.send(HandlerCommand::SetClient {
            client,
            initialized: initialized_tx,
        }) {
            self.release_limit_reservations();
            anyhow::bail!("Failed to send SetClient command: {e}");
        }

        {
            let mut command_sender = self.cmd_tx.write().await;
            // Synchronous cache updates share the snapshot and sender handoff
            let mut cache_sender = self.cache_tx.lock();
            // Initialize handler with existing instruments
            let instruments_vec: Vec<InstrumentAny> =
                self.instruments.load().values().cloned().collect();

            if !instruments_vec.is_empty()
                && let Err(e) = cmd_tx.send(HandlerCommand::InitializeInstruments(instruments_vec))
            {
                log::error!("Failed to send InitializeInstruments: {e}");
            }

            for (coin, uses) in self.trade_streams.snapshot() {
                if let Err(e) = cmd_tx.send(HandlerCommand::UpdateTradeSubs { coin, uses }) {
                    log::error!("Failed to send UpdateTradeSubs: {e}");
                }
            }

            let all_dex_asset_ctxs_instrument_ids = self
                .all_dex_asset_ctxs_instrument_ids
                .load()
                .iter()
                .map(|(dex, instrument_ids)| (*dex, instrument_ids.clone()))
                .collect();

            if let Err(e) = cmd_tx.send(HandlerCommand::CacheAllDexAssetCtxsInstrumentIds(
                all_dex_asset_ctxs_instrument_ids,
            )) {
                log::error!("Failed to send CacheAllDexAssetCtxsInstrumentIds: {e}");
            }

            *cache_sender = cmd_tx.clone();
            *command_sender = cmd_tx.clone();
        }

        // Spawn handler task
        let signal = Arc::clone(&self.signal);
        let account_id = self.account_id;
        let subscriptions = self.subscriptions.clone();
        let book_streams = self.book_streams.clone();
        let cmd_tx_for_reconnect = cmd_tx.clone();
        let cloid_cache = Arc::clone(&self.cloid_cache);
        let post_router = Arc::clone(&self.post_router);
        let rate_limits = Arc::clone(&self.rate_limits);
        let client_id = self.client_id;
        let connection_permit = Arc::clone(&self.connection_permit);

        if let Err(e) = self.task_handle.spawn(async move {
            let mut handler = FeedHandler::new(
                signal,
                cmd_rx,
                raw_rx,
                out_tx,
                account_id,
                subscriptions.clone(),
                cloid_cache,
                post_router,
                Arc::clone(&rate_limits),
                client_id,
            );

            let resubscribe_all = || {
                let topics = subscriptions.all_topics();
                if topics.is_empty() {
                    log::debug!("No active subscriptions to restore after reconnection");
                    return;
                }

                log::info!(
                    "Resubscribing to {} active subscriptions after reconnection",
                    topics.len()
                );

                for topic in topics {
                    match subscription_from_topic(&topic) {
                        Ok(mut subscription) => {
                            // Topic text cannot carry l2Book precision options;
                            // replay the shape the stream was opened with
                            if let SubscriptionRequest::L2Book {
                                coin,
                                n_sig_figs,
                                mantissa,
                            } = &mut subscription
                                && let Some(options) = book_streams.options(coin)
                            {
                                *n_sig_figs = options.n_sig_figs;
                                *mantissa = options.mantissa;
                            }

                            if let Err(e) = cmd_tx_for_reconnect.send(HandlerCommand::Subscribe {
                                subscriptions: vec![subscription],
                            }) {
                                log::error!("Failed to send resubscribe command: {e}");
                            }
                        }
                        Err(e) => {
                            log::error!(
                                "Failed to reconstruct subscription from topic: topic={topic}, {e}"
                            );
                        }
                    }
                }
            };

            loop {
                match handler.next().await {
                    Some(NautilusWsMessage::Reconnected) => {
                        log::info!("WebSocket reconnected");
                        let pending_unsubscribe = subscriptions.pending_unsubscribe_topics();
                        rate_limits.release_subscriptions(
                            client_id,
                            pending_unsubscribe.iter().map(String::as_str),
                        );
                        subscriptions.reset_after_reconnect();
                        resubscribe_all();

                        if handler.send(NautilusWsMessage::Reconnected).is_err() {
                            if handler.is_stopped() {
                                log::debug!("Failed to send reconnect event (receiver dropped)");
                            } else {
                                log::error!("Failed to send reconnect event (receiver dropped)");
                            }
                            break;
                        }
                    }
                    Some(msg) => {
                        if handler.send(msg).is_err() {
                            if handler.is_stopped() {
                                log::debug!("Failed to send message (receiver dropped)");
                            } else {
                                log::error!("Failed to send message (receiver dropped)");
                            }
                            break;
                        }
                    }
                    None => {
                        if handler.is_stopped() {
                            log::debug!("Stop signal received, ending message processing");
                            break;
                        }
                        log::warn!("WebSocket stream ended unexpectedly");
                        break;
                    }
                }
            }
            rate_limits.release_client(client_id);
            connection_permit.lock().take();
            log::debug!("Handler task completed");
        }) {
            self.out_rx = None;
            self.release_limit_reservations();
            anyhow::bail!("Failed to start Hyperliquid WebSocket handler task: {e}");
        }

        self.wait_for_initialization(initialized_rx, connection_mode)
            .await?;

        log::debug!("Hyperliquid WebSocket connected: {}", self.url.origin());

        Ok(())
    }

    async fn wait_for_initialization(
        &mut self,
        initialized: tokio::sync::oneshot::Receiver<()>,
        connection_mode: Arc<AtomicU8>,
    ) -> anyhow::Result<()> {
        let setup_guard = TaskGroupGuard::new(&[], || {
            self.task_handle.abort();
            self.release_limit_reservations();
        });

        let result = tokio::time::timeout(HTTP_TIMEOUT, initialized)
            .await
            .context("Hyperliquid WebSocket handler initialization timed out")
            .and_then(|result| {
                result.context("Hyperliquid WebSocket handler stopped before initialization")
            });

        if result.is_ok() {
            self.connection_mode.store(connection_mode);
            setup_guard.disarm();
            return Ok(());
        }

        drop(setup_guard);
        self.out_rx = None;
        self.disconnect_locked().await?;
        result
    }

    pub fn set_post_timeout(&mut self, timeout: Duration) {
        self.post_timeout = timeout;
    }

    pub(crate) fn begin_shutdown(&self) {
        self.signal.store(true, Ordering::Relaxed);
    }

    /// Replaces state owned by a terminated WebSocket generation.
    ///
    /// This must run only after the handler task has stopped. Replacing the
    /// shared containers, rather than clearing them, prevents old clones or
    /// in-flight work from mutating a subsequent connection generation.
    pub(crate) fn reset_runtime_state(&mut self) {
        self.release_limit_reservations();
        self.subscriptions = SubscriptionState::new(':');
        self.book_streams = BookStreamRegistry::default();
        self.trade_streams = TradeStreamRegistry::default();
        self.trade_stream_lock = Arc::new(Mutex::new(()));
        self.quote_streams = Arc::new(DashMap::new());
        self.instruments = Arc::new(AtomicMap::new());
        let (cache_tx, _) = tokio::sync::mpsc::unbounded_channel();
        self.cache_tx = Arc::new(Mutex::new(cache_tx));
        self.bar_types = Arc::new(AtomicMap::new());
        self.asset_context_subs = Arc::new(DashMap::new());
        self.all_dex_asset_ctxs_instrument_ids = Arc::new(AtomicMap::new());
        self.cloid_cache = Arc::new(Mutex::new(FifoCacheMap::new()));
        self.out_rx = None;

        if let Some(control) = &self.socket_control {
            control.deregister();
        }
        self.connection_mode
            .store(Arc::new(AtomicU8::new(ConnectionMode::Closed as u8)));
        self.signal.store(false, Ordering::Relaxed);
    }

    /// Disconnects the WebSocket connection.
    pub async fn disconnect(&mut self) -> anyhow::Result<()> {
        let connect_lock = Arc::clone(&self.connect_lock);
        let _guard = connect_lock.lock().await;
        self.disconnect_locked().await
    }

    async fn disconnect_locked(&self) -> anyhow::Result<()> {
        log::debug!("Disconnecting Hyperliquid WebSocket");

        if let Some(control) = &self.socket_control {
            control.deregister();
        }
        self.signal.store(true, Ordering::Relaxed);

        if let Err(e) = self.cmd_tx.read().await.send(HandlerCommand::Disconnect) {
            log::debug!(
                "Failed to send disconnect command (handler may already be shut down): {e}"
            );
        }

        if self.task_handle.is_empty() {
            log::debug!("No task handle to await");
        } else {
            log::debug!("Waiting for task handle to complete");

            if let Some(outcome) = self
                .task_handle
                .finish(Duration::from_secs(2), Duration::from_secs(2))
                .await
            {
                match outcome {
                    TaskJoinOutcome::Completed(()) | TaskJoinOutcome::Aborted => {}
                    TaskJoinOutcome::Failed(error) => {
                        self.release_limit_reservations();
                        anyhow::bail!("Hyperliquid WebSocket handler failed: {error}");
                    }
                    TaskJoinOutcome::Incomplete => {
                        self.release_limit_reservations();
                        anyhow::bail!("Hyperliquid WebSocket handler did not stop after abort");
                    }
                }
            }
        }
        self.release_limit_reservations();
        log::debug!("Disconnected");
        Ok(())
    }

    /// Requests a full transport reconnect.
    ///
    /// Transitions the connection from `Active` to `Reconnect`; the network
    /// layer re-establishes the socket with backoff and the handler replays all
    /// active subscriptions once reconnected. Returns `false` when the
    /// connection is not active (already reconnecting, disconnecting, or
    /// closed), leaving any in-flight transition untouched.
    pub fn request_reconnect(&self) -> bool {
        ConnectionMode::request_reconnect(&self.connection_mode.load())
    }

    /// Send a typed exchange action through the Hyperliquid WebSocket post API.
    ///
    /// The supplied HTTP client is used only as the canonical signer for the
    /// action envelope. The signed payload is sent over the active WebSocket
    /// connection and the response is correlated by post id.
    pub async fn post_action_exec(
        &self,
        signer: &HyperliquidHttpClient,
        action: &HyperliquidExchangeAction,
    ) -> HyperliquidResult<HyperliquidExchangeResponse> {
        self.post_action_exec_with_timeout(signer, action, self.post_timeout, None)
            .await
    }

    /// Send a typed exchange action with a caller-specified timeout and optional expiry.
    pub async fn post_action_exec_with_timeout(
        &self,
        signer: &HyperliquidHttpClient,
        action: &HyperliquidExchangeAction,
        timeout: Duration,
        expires_after: Option<u64>,
    ) -> HyperliquidResult<HyperliquidExchangeResponse> {
        self.post_action_result(signer, action, timeout, expires_after)
            .await
            .map_err(PostRequestError::into_error)
    }

    pub(crate) async fn post_action_command(
        &self,
        signer: &HyperliquidHttpClient,
        action: &HyperliquidExchangeAction,
    ) -> Result<HyperliquidExchangeResponse, PostRequestError> {
        self.post_action_result(signer, action, self.post_timeout, None)
            .await
    }

    async fn post_action_result(
        &self,
        signer: &HyperliquidHttpClient,
        action: &HyperliquidExchangeAction,
        timeout: Duration,
        expires_after: Option<u64>,
    ) -> Result<HyperliquidExchangeResponse, PostRequestError> {
        let weight = exec_action_weight(action);
        let payload = signer
            .sign_action_exec_request(action, expires_after)
            .map_err(PostRequestError::BeforeDispatch)?;
        let response = self
            .send_post_request_result(PostRequest::Action { payload }, timeout)
            .await?;

        match response.response {
            PostResponsePayload::Action { payload } => {
                let parsed = self
                    .parse_post_action_payload(&payload)
                    .map_err(PostRequestError::AfterDispatch)?;

                self.check_post_action_response(parsed)
            }
            PostResponsePayload::Error { payload } => Err(PostRequestError::AfterDispatch(
                map_post_payload_error(payload, weight),
            )),
            PostResponsePayload::Info { payload } => Err(PostRequestError::AfterDispatch(
                HyperliquidError::decode(self.post_decode_context(&payload, "unexpected_info")),
            )),
        }
    }

    /// Submit an order through the Hyperliquid WebSocket post API.
    ///
    /// The HTTP client supplies signing credentials, builder attribution, and
    /// cached instrument metadata. The action itself is sent over WebSocket.
    ///
    /// Returns an [`OrderStatusReport`] describing the venue's immediate
    /// response (`Filled` for an atomic IOC fill, `Accepted` for a resting
    /// order), or `None` when the venue deferred the order without an oid (for
    /// example a `waitingForFill` trigger child): the order stays `SUBMITTED`
    /// until the user-events stream delivers the first `OrderAccepted`.
    #[allow(
        clippy::too_many_arguments,
        reason = "matches the Python and HTTP order submit surface"
    )]
    pub async fn submit_order(
        &self,
        signer: &HyperliquidHttpClient,
        instrument_id: InstrumentId,
        client_order_id: ClientOrderId,
        order_side: OrderSide,
        order_type: OrderType,
        quantity: Quantity,
        time_in_force: TimeInForce,
        price: Option<Price>,
        trigger_price: Option<Price>,
        post_only: bool,
        reduce_only: bool,
    ) -> HyperliquidResult<Option<OrderStatusReport>> {
        let symbol = instrument_id.symbol.inner();
        let asset = signer.get_asset_index_for_symbol(symbol).ok_or_else(|| {
            HyperliquidError::bad_request(format!(
                "Asset index not found for symbol: {symbol}. Ensure instruments are loaded."
            ))
        })?;
        let is_buy = matches!(order_side, OrderSide::Buy);
        let price_precision = signer.get_price_precision_for_symbol(symbol);

        let price_decimal = match price {
            Some(px) => normalize_or_validate_wire_price(
                px.as_decimal(),
                "Price",
                price_precision,
                signer.normalize_prices(),
            )
            .map_err(|e| HyperliquidError::bad_request(format!("{e}")))?,
            None if matches!(order_type, OrderType::Market) => Decimal::ZERO,
            None if matches!(
                order_type,
                OrderType::StopMarket | OrderType::MarketIfTouched
            ) =>
            {
                match trigger_price {
                    Some(tp) => {
                        let derived = derive_limit_from_trigger(
                            tp.as_decimal().normalize(),
                            is_buy,
                            signer.market_order_slippage_bps(),
                        );
                        let sig_rounded = round_to_sig_figs(derived, 5);
                        clamp_price_to_precision(sig_rounded, price_precision.unwrap_or(2), is_buy)
                            .normalize()
                    }
                    None => Decimal::ZERO,
                }
            }
            None => {
                return Err(HyperliquidError::bad_request(
                    "Limit orders require a price",
                ));
            }
        };

        let size_decimal = quantity.as_decimal().normalize();
        let kind = hyperliquid_order_kind(
            order_type,
            time_in_force,
            post_only,
            trigger_price,
            signer.normalize_prices(),
            price_precision,
        )?;

        let order = HyperliquidExchangePlaceOrderRequest {
            asset,
            is_buy,
            price: price_decimal,
            size: size_decimal,
            reduce_only,
            kind,
            cloid: Some(signer.get_or_generate_client_order_id_cloid(client_order_id)),
        };

        if let Some(cloid) = order.cloid {
            self.cache_cloid_mapping(Ustr::from(&cloid.to_hex()), client_order_id);
        }
        let action = HyperliquidExchangeAction::Order {
            orders: vec![order],
            grouping: HyperliquidExchangeGrouping::Na,
            builder: signer.builder_attribution(),
        };
        let response = self.post_action_exec(signer, &action).await?;

        // Verdict first: a real rejection must still error
        ensure_ws_action_accepted(&response, "Order submission")?;

        let payload_bytes = Self::response_bytes(&response);

        // Past the verdict, a build failure is local; defer to WS, never reject
        let report = signer.build_submit_order_report(
            instrument_id,
            client_order_id,
            order_side,
            order_type,
            quantity,
            time_in_force,
            price,
            trigger_price,
            response,
        );
        Ok(self.resolve_submit_report(report, payload_bytes))
    }

    /// Submit multiple orders through the Hyperliquid WebSocket post API.
    ///
    /// Returns one [`OrderStatusReport`] per accepted order in submission
    /// order. Deferred trigger children of a `normalTpsl` bracket are absent
    /// from the result; they stay `SUBMITTED` until the user-events stream
    /// delivers an `OrderAccepted` with the real oid.
    ///
    /// # Errors
    ///
    /// Returns an error if any quantity is quote-denominated: this raw path has no cached market
    /// data for a quote-to-base conversion, so such orders must be submitted through the execution
    /// client instead.
    pub async fn submit_orders(
        &self,
        signer: &HyperliquidHttpClient,
        orders: &[&OrderAny],
    ) -> HyperliquidResult<Vec<OrderStatusReport>> {
        let mut hyperliquid_orders = Vec::with_capacity(orders.len());
        let mut client_order_ids = Vec::with_capacity(orders.len());

        for order in orders {
            if order.is_quote_quantity() {
                return Err(HyperliquidError::bad_request(format!(
                    "Quote-denominated quantity order {} must submit through the execution \
                     client for quote-to-base conversion",
                    order.client_order_id()
                )));
            }

            let instrument_id = order.instrument_id();
            let symbol = instrument_id.symbol.inner();
            let asset = signer.get_asset_index_for_symbol(symbol).ok_or_else(|| {
                HyperliquidError::bad_request(format!(
                    "Asset index not found for symbol: {symbol}. Ensure instruments are loaded."
                ))
            })?;
            let price_decimals = signer.get_price_precision_for_symbol(symbol);
            let request = order_to_hyperliquid_request_with_optional_decimals(
                order,
                asset,
                price_decimals,
                signer.normalize_prices(),
                signer.market_order_slippage_bps(),
                None,
            )
            .map_err(|e| HyperliquidError::bad_request(format!("Failed to convert order: {e}")))?;
            client_order_ids.push(order.client_order_id());
            hyperliquid_orders.push(request);
        }

        for (request, client_order_id) in hyperliquid_orders.iter_mut().zip(client_order_ids) {
            let cloid = signer.get_or_generate_client_order_id_cloid(client_order_id);
            request.cloid = Some(cloid);
            self.cache_cloid_mapping(Ustr::from(&cloid.to_hex()), client_order_id);
        }

        let grouping =
            determine_order_list_grouping(&orders.iter().copied().cloned().collect::<Vec<_>>());
        let action = HyperliquidExchangeAction::Order {
            orders: hyperliquid_orders,
            grouping,
            builder: signer.builder_attribution(),
        };
        let response = self.post_action_exec(signer, &action).await?;

        ensure_ws_action_accepted(&response, "Order list submission")?;

        let payload_bytes = Self::response_bytes(&response);

        // Past the verdict, a build failure is local; defer to WS, never reject
        let reports = signer.build_submit_orders_reports(orders, grouping, response);
        Ok(self.resolve_submit_report(reports, payload_bytes))
    }

    /// Cancel an order through the Hyperliquid WebSocket post API.
    pub async fn cancel_order(
        &self,
        signer: &HyperliquidHttpClient,
        instrument_id: InstrumentId,
        client_order_id: Option<ClientOrderId>,
        venue_order_id: Option<VenueOrderId>,
    ) -> HyperliquidResult<()> {
        let symbol = instrument_id.symbol.inner();
        let asset = signer.get_asset_index_for_symbol(symbol).ok_or_else(|| {
            HyperliquidError::bad_request(format!(
                "Asset index not found for symbol: {symbol}. Ensure instruments are loaded."
            ))
        })?;
        let action = if let Some(client_order_id) = client_order_id {
            if let Some(cloid) = signer.cached_client_order_id_cloid(&client_order_id) {
                HyperliquidExchangeAction::CancelByCloid {
                    cancels: vec![HyperliquidExchangeCancelByCloidRequest { asset, cloid }],
                    fast: None,
                }
            } else if let Some(oid) = venue_order_id {
                let oid = oid
                    .as_str()
                    .parse::<u64>()
                    .map_err(|_| HyperliquidError::bad_request("Invalid venue order ID format"))?;
                HyperliquidExchangeAction::Cancel {
                    cancels: vec![HyperliquidExchangeCancelOrderRequest { asset, oid }],
                    fast: None,
                }
            } else {
                let cloid = signer.get_or_generate_client_order_id_cloid(client_order_id);
                HyperliquidExchangeAction::CancelByCloid {
                    cancels: vec![HyperliquidExchangeCancelByCloidRequest { asset, cloid }],
                    fast: None,
                }
            }
        } else if let Some(oid) = venue_order_id {
            let oid = oid
                .as_str()
                .parse::<u64>()
                .map_err(|_| HyperliquidError::bad_request("Invalid venue order ID format"))?;
            HyperliquidExchangeAction::Cancel {
                cancels: vec![HyperliquidExchangeCancelOrderRequest { asset, oid }],
                fast: None,
            }
        } else {
            return Err(HyperliquidError::bad_request(
                "Either client_order_id or venue_order_id must be provided",
            ));
        };
        let response = self.post_action_exec(signer, &action).await?;

        ensure_ws_action_accepted(&response, "Cancel order")
    }

    /// Cancel multiple orders through one Hyperliquid WebSocket post action.
    pub async fn cancel_orders(
        &self,
        signer: &HyperliquidHttpClient,
        cancels: &[(InstrumentId, ClientOrderId, Option<VenueOrderId>)],
    ) -> HyperliquidResult<Vec<Option<String>>> {
        let mut cloid_requests = Vec::new();
        let mut cloid_indices = Vec::new();
        let mut oid_requests = Vec::new();
        let mut oid_indices = Vec::new();
        let mut results = vec![None; cancels.len()];

        for (index, (instrument_id, client_order_id, venue_order_id)) in cancels.iter().enumerate()
        {
            let symbol = instrument_id.symbol.inner();
            let Some(asset) = signer.get_asset_index_for_symbol(symbol) else {
                results[index] = Some(format!(
                    "Asset index not found for symbol: {symbol}. Ensure instruments are loaded."
                ));
                continue;
            };

            if let Some(cloid) = signer.cached_client_order_id_cloid(client_order_id) {
                cloid_requests.push(HyperliquidExchangeCancelByCloidRequest { asset, cloid });
                cloid_indices.push(index);
            } else if let Some(venue_order_id) = venue_order_id {
                match venue_order_id.as_str().parse::<u64>() {
                    Ok(oid) => {
                        oid_requests.push(HyperliquidExchangeCancelOrderRequest { asset, oid });
                        oid_indices.push(index);
                    }
                    Err(_) => {
                        results[index] = Some("Invalid venue order ID format".to_string());
                    }
                }
            } else {
                let cloid = signer.get_or_generate_client_order_id_cloid(*client_order_id);
                cloid_requests.push(HyperliquidExchangeCancelByCloidRequest { asset, cloid });
                cloid_indices.push(index);
            }
        }

        if cloid_requests.is_empty() && oid_requests.is_empty() {
            return Ok(results);
        }

        if !cloid_requests.is_empty() {
            let action = HyperliquidExchangeAction::CancelByCloid {
                cancels: cloid_requests,
                fast: None,
            };
            let errors = self
                .post_cancel_action_errors(signer, &action, cloid_indices.len())
                .await?;

            for (index, error) in cloid_indices.into_iter().zip(errors) {
                results[index] = error;
            }
        }

        if !oid_requests.is_empty() {
            let action = HyperliquidExchangeAction::Cancel {
                cancels: oid_requests,
                fast: None,
            };
            let errors = self
                .post_cancel_action_errors(signer, &action, oid_indices.len())
                .await?;

            for (index, error) in oid_indices.into_iter().zip(errors) {
                results[index] = error;
            }
        }

        Ok(results)
    }

    async fn post_cancel_action_errors(
        &self,
        signer: &HyperliquidHttpClient,
        action: &HyperliquidExchangeAction,
        request_count: usize,
    ) -> HyperliquidResult<Vec<Option<String>>> {
        match self.post_cancel_action(signer, action).await {
            Ok(response) if response.is_ok() => {
                match cancel_errors_for_requests(extract_inner_errors(&response), request_count) {
                    Ok(errors) => Ok(errors),
                    Err(e) => Ok(vec![Some(e.to_string()); request_count]),
                }
            }
            Ok(response) => Ok(self.cancel_response_errors(&response, request_count)),
            Err(e) => Err(e),
        }
    }

    async fn post_cancel_action(
        &self,
        signer: &HyperliquidHttpClient,
        action: &HyperliquidExchangeAction,
    ) -> HyperliquidResult<HyperliquidExchangeResponse> {
        let weight = exec_action_weight(action);

        let payload = signer.sign_action_exec_request(action, None)?;
        let response = self
            .send_post_request(PostRequest::Action { payload }, self.post_timeout)
            .await?;

        match response.response {
            PostResponsePayload::Action { payload } => self.parse_post_action_payload(&payload),
            PostResponsePayload::Error { payload } => Err(map_post_payload_error(payload, weight)),
            PostResponsePayload::Info { payload } => Err(HyperliquidError::decode(
                self.post_decode_context(&payload, "unexpected_info"),
            )),
        }
    }

    fn response_bytes(response: &HyperliquidExchangeResponse) -> usize {
        match response {
            HyperliquidExchangeResponse::Status { response, .. } => response.to_string().len(),
            HyperliquidExchangeResponse::Error { error } => error.len(),
        }
    }

    fn resolve_submit_report<T: Default>(
        &self,
        result: HyperliquidResult<T>,
        payload_bytes: usize,
    ) -> T {
        match result {
            Ok(report) => report,
            Err(_) => {
                log::warn!(
                    "Failed to build WebSocket submit report: class=order_status, client_id={}, payload_bytes={payload_bytes}, category=conversion; awaiting WS reconciliation",
                    self.client_id,
                );
                T::default()
            }
        }
    }

    fn parse_post_action_payload(
        &self,
        payload: &serde_json::Value,
    ) -> HyperliquidResult<HyperliquidExchangeResponse> {
        HyperliquidExchangeResponse::deserialize(payload).map_err(|e| {
            let category = format!("{:?}", e.classify());
            let context = self.post_decode_context(payload, &category);
            HyperliquidError::Serde(<serde_json::Error as serde::de::Error>::custom(context))
        })
    }

    fn check_post_action_response(
        &self,
        parsed: HyperliquidExchangeResponse,
    ) -> Result<HyperliquidExchangeResponse, PostRequestError> {
        self.check_post_status(&parsed)
            .map_err(PostRequestError::AfterDispatch)?;

        match &parsed {
            HyperliquidExchangeResponse::Status { status, response }
                if status == RESPONSE_STATUS_ERR =>
            {
                let reason = response
                    .as_str()
                    .map_or_else(|| response.to_string(), str::to_string);
                let error = HyperliquidError::bad_request(format!("API error: {reason}"));
                Err(PostRequestError::Rejected {
                    error,
                    reason: extract_error_message(&parsed),
                })
            }
            HyperliquidExchangeResponse::Error { error } => Err(PostRequestError::Rejected {
                error: HyperliquidError::bad_request(format!("API error: {error}")),
                reason: error.clone(),
            }),
            _ => Ok(parsed),
        }
    }

    fn cancel_response_errors(
        &self,
        response: &HyperliquidExchangeResponse,
        request_count: usize,
    ) -> Vec<Option<String>> {
        let reason = self
            .check_post_status(response)
            .err()
            .map_or_else(|| extract_error_message(response), |e| e.to_string());
        let reason = format!("Cancel orders failed: {reason}");
        vec![Some(reason); request_count]
    }

    fn check_post_status(&self, parsed: &HyperliquidExchangeResponse) -> HyperliquidResult<()> {
        if let HyperliquidExchangeResponse::Status { status, response } = parsed
            && status != RESPONSE_STATUS_OK
            && status != RESPONSE_STATUS_ERR
        {
            let context = self.post_decode_context(response, "unexpected_status");
            return Err(HyperliquidError::bad_request(context));
        }

        Ok(())
    }

    fn post_decode_context(&self, payload: &serde_json::Value, category: &str) -> String {
        format!(
            "Invalid WebSocket post response: class=action, client_id={}, payload_bytes={}, category={category}",
            self.client_id,
            payload.to_string().len(),
        )
    }

    /// Modify an order through the Hyperliquid WebSocket post API.
    #[allow(
        clippy::too_many_arguments,
        reason = "matches the Python and HTTP order modify surface"
    )]
    pub async fn modify_order(
        &self,
        signer: &HyperliquidHttpClient,
        instrument_id: InstrumentId,
        venue_order_id: Option<VenueOrderId>,
        order_side: OrderSide,
        order_type: OrderType,
        price: Price,
        quantity: Quantity,
        trigger_price: Option<Price>,
        reduce_only: bool,
        post_only: bool,
        time_in_force: TimeInForce,
        client_order_id: Option<ClientOrderId>,
    ) -> HyperliquidResult<()> {
        let symbol = instrument_id.symbol.inner();
        let asset = signer.get_asset_index_for_symbol(symbol).ok_or_else(|| {
            HyperliquidError::bad_request(format!(
                "Asset index not found for symbol: {symbol}. Ensure instruments are loaded."
            ))
        })?;
        let oid = match client_order_id
            .as_ref()
            .and_then(|id| signer.unique_cached_client_order_id_cloid(id))
        {
            Some(cloid) => HyperliquidExchangeModifyTarget::Cloid(cloid),
            None => {
                let Some(venue_order_id) = venue_order_id.as_ref() else {
                    return Err(HyperliquidError::bad_request(
                        "venue_order_id or unique cached CLOID is required for modify",
                    ));
                };
                HyperliquidExchangeModifyTarget::from_venue_order_id(venue_order_id)
                    .map_err(|_| HyperliquidError::bad_request("Invalid venue order ID format"))?
            }
        };
        let is_buy = matches!(order_side, OrderSide::Buy);
        let price_decimals = signer.get_price_precision_for_symbol(symbol);
        let price = normalize_or_validate_wire_price(
            price.as_decimal(),
            "Price",
            price_decimals,
            signer.normalize_prices(),
        )
        .map_err(|e| HyperliquidError::bad_request(format!("{e}")))?;
        let kind = hyperliquid_order_kind(
            order_type,
            time_in_force,
            post_only,
            trigger_price,
            signer.normalize_prices(),
            price_decimals,
        )?;
        let cloid =
            client_order_id.map(|id| (id, signer.get_or_generate_client_order_id_cloid(id)));
        let order = HyperliquidExchangePlaceOrderRequest {
            asset,
            is_buy,
            price,
            size: quantity.as_decimal().normalize(),
            reduce_only,
            kind,
            cloid: cloid.map(|(_, cloid)| cloid),
        };

        if let Some((client_order_id, cloid)) = cloid {
            self.cache_cloid_mapping(Ustr::from(&cloid.to_hex()), client_order_id);
        }
        let action = HyperliquidExchangeAction::Modify {
            modify: HyperliquidExchangeModifyOrderRequest { oid, order },
        };
        let response = self.post_action_exec(signer, &action).await?;

        ensure_ws_action_accepted(&response, "Modify order")
    }

    async fn send_post_request(
        &self,
        request: PostRequest,
        timeout: Duration,
    ) -> HyperliquidResult<PostResponse> {
        self.send_post_request_result(request, timeout)
            .await
            .map_err(PostRequestError::into_error)
    }

    async fn send_post_request_result(
        &self,
        request: PostRequest,
        timeout: Duration,
    ) -> Result<PostResponse, PostRequestError> {
        let id = self.post_ids.next();
        let Some(deadline) = tokio::time::Instant::now().checked_add(timeout) else {
            return Err(PostRequestError::BeforeDispatch(HyperliquidError::Timeout));
        };

        let cancellation_token = CancellationToken::new();
        let rx = tokio::select! {
            biased;
            () = tokio::time::sleep_until(deadline) => return Err(PostRequestError::BeforeDispatch(HyperliquidError::Timeout)),
            result = self.post_router.register_with_cancellation(id, &cancellation_token) => result.map_err(PostRequestError::BeforeDispatch)?,
        };

        let _cancellation_guard = cancellation_token.drop_guard_ref();

        let send_result = {
            let cmd_tx = tokio::select! {
                biased;
                () = tokio::time::sleep_until(deadline) => {
                    self.cancel_post_registration(id, &cancellation_token).await;
                    return Err(PostRequestError::BeforeDispatch(HyperliquidError::Timeout));
                }
                cmd_tx = self.cmd_tx.read() => cmd_tx,
            };

            if cancellation_token.is_cancelled() || tokio::time::Instant::now() >= deadline {
                self.cancel_post_registration(id, &cancellation_token).await;
                return Err(PostRequestError::BeforeDispatch(HyperliquidError::Timeout));
            }

            cmd_tx.send(HandlerCommand::Post {
                id,
                request,
                deadline,
                cancellation_token: cancellation_token.clone(),
            })
        };

        if let Err(e) = send_result {
            self.cancel_post_registration(id, &cancellation_token).await;
            return Err(PostRequestError::BeforeDispatch(
                HyperliquidError::transport(format!("post command channel closed: {e}")),
            ));
        }

        self.await_post_response(id, rx, deadline, &cancellation_token)
            .await
            .map_err(PostRequestError::AfterDispatch)
    }

    async fn await_post_response(
        &self,
        id: u64,
        rx: tokio::sync::oneshot::Receiver<PostResponse>,
        deadline: tokio::time::Instant,
        cancellation_token: &CancellationToken,
    ) -> HyperliquidResult<PostResponse> {
        tokio::select! {
            biased;
            result = rx => match result {
                Ok(response) => Ok(response),
                Err(_closed) => {
                    self.cancel_post_registration(id, cancellation_token).await;
                    Err(HyperliquidError::transport("post response channel closed"))
                },
            },
            () = tokio::time::sleep_until(deadline) => {
                self.cancel_post_registration(id, cancellation_token).await;
                Err(HyperliquidError::Timeout)
            },
        }
    }

    async fn cancel_post_registration(&self, id: u64, cancellation_token: &CancellationToken) {
        cancellation_token.cancel();
        self.post_router
            .cancel_registration(id, cancellation_token)
            .await;
    }

    /// Returns true if the WebSocket is actively connected.
    pub fn is_active(&self) -> bool {
        let mode = self.connection_mode.load();
        mode.load(Ordering::Relaxed) == ConnectionMode::Active as u8
    }

    /// Returns the URL of this WebSocket client.
    pub fn url(&self) -> &str {
        self.url.expose()
    }

    /// Caches multiple instruments.
    ///
    /// Clears the existing cache first, then adds all provided instruments.
    /// Instruments are keyed by their raw_symbol which is unique per instrument:
    /// - Perps use base currency (e.g., "BTC")
    /// - Spot uses @{pair_index} format (e.g., "@107") or slash format for PURR
    pub fn cache_instruments(&mut self, instruments: Vec<InstrumentAny>) {
        let mut map = AHashMap::new();

        for inst in instruments {
            let coin = inst.raw_symbol().inner();
            map.insert(coin, inst);
        }
        let count = map.len();
        let _guard = self.cache_tx.lock();
        self.instruments.store(map);
        log::debug!("Hyperliquid instrument cache initialized with {count} instruments");
    }

    /// Caches a single instrument.
    ///
    /// Any existing instrument with the same raw_symbol will be replaced.
    pub fn cache_instrument(&self, instrument: InstrumentAny) {
        self.merge_instruments(&[instrument]);
    }

    pub(crate) fn merge_instruments(&self, instruments: &[InstrumentAny]) {
        if instruments.is_empty() {
            return;
        }

        let cmd_tx = self.cache_tx.lock();
        self.instruments.rcu(|cache| {
            for instrument in instruments {
                cache.insert(instrument.raw_symbol().inner(), instrument.clone());
            }
        });

        // Before connect() the handler isn't running; this send will fail and that's expected
        // because connect() replays the instruments via InitializeInstruments
        for instrument in instruments {
            let _ = cmd_tx.send(HandlerCommand::UpdateInstrument(instrument.clone()));
        }
    }

    /// Returns a shared reference to the instrument cache.
    #[must_use]
    pub fn instruments_cache(&self) -> Arc<AtomicMap<Ustr, InstrumentAny>> {
        self.instruments.clone()
    }

    /// Caches spot fill coin mappings for instrument lookup.
    ///
    /// Hyperliquid WebSocket fills for spot use `@{pair_index}` format (e.g., `@107`),
    /// while instruments are identified by full symbols (e.g., `HYPE-USDC-SPOT`).
    /// This mapping allows the handler to look up instruments from spot fills.
    pub fn cache_spot_fill_coins(&self, mapping: AHashMap<Ustr, Ustr>) {
        if let Ok(cmd_tx) = self.cmd_tx.try_read() {
            let _ = cmd_tx.send(HandlerCommand::CacheSpotFillCoins(mapping));
        }
    }

    /// Caches a venue CLOID to client_order_id mapping for order/fill resolution.
    ///
    /// This mapping allows WebSocket order status and fill reports to be resolved back to
    /// the original client_order_id.
    ///
    /// This writes directly to a shared cache that the handler reads from, avoiding any
    /// race conditions between caching and WebSocket message processing.
    pub fn cache_cloid_mapping(&self, cloid: Ustr, client_order_id: ClientOrderId) {
        log::debug!("Caching cloid mapping: {cloid} -> {client_order_id}");
        self.cloid_cache.lock().insert(cloid, client_order_id);
    }

    /// Removes a cloid mapping from the cache.
    ///
    /// Called on terminal order state. The cache is FIFO-bounded so missed
    /// removals self-evict (see GH-3972 cancel-replace drain).
    pub fn remove_cloid_mapping(&self, cloid: &Ustr) {
        if self.cloid_cache.lock().remove(cloid).is_some() {
            log::debug!("Removed cloid mapping: {cloid}");
        }
    }

    /// Clears all cloid mappings from the cache.
    ///
    /// Useful for cleanup during reconnection or shutdown.
    pub fn clear_cloid_cache(&self) {
        let mut cache = self.cloid_cache.lock();
        let count = cache.len();
        cache.clear();

        if count > 0 {
            log::debug!("Cleared {count} cloid mappings from cache");
        }
    }

    /// Returns the number of cloid mappings in the cache.
    #[must_use]
    pub fn cloid_cache_len(&self) -> usize {
        self.cloid_cache.lock().len()
    }

    /// Looks up a client_order_id by its venue CLOID.
    ///
    /// Returns `Some(ClientOrderId)` if the mapping exists, `None` otherwise.
    #[must_use]
    pub fn get_cloid_mapping(&self, cloid: &Ustr) -> Option<ClientOrderId> {
        self.cloid_cache.lock().get(cloid).copied()
    }

    /// Gets an instrument from the cache by ID.
    ///
    /// Searches the cache for a matching instrument ID.
    pub fn get_instrument(&self, id: &InstrumentId) -> Option<InstrumentAny> {
        self.instruments
            .load()
            .values()
            .find(|inst| inst.id() == *id)
            .cloned()
    }

    /// Gets an instrument from the cache by raw_symbol (coin).
    pub fn get_instrument_by_symbol(&self, symbol: &Ustr) -> Option<InstrumentAny> {
        self.instruments.get_cloned(symbol)
    }

    /// Returns the count of confirmed subscriptions.
    pub fn subscription_count(&self) -> usize {
        self.subscriptions.len()
    }

    pub(crate) async fn wait_for_subscriptions_confirmed(
        &self,
        timeout: Duration,
    ) -> anyhow::Result<()> {
        tokio::time::timeout(timeout, async {
            while !self.subscriptions.pending_subscribe_topics().is_empty() {
                tokio::time::sleep(Duration::from_millis(10)).await;
            }
        })
        .await
        .map_err(|_| {
            anyhow::anyhow!(
                "Subscriptions still pending after {timeout:?}: {:?}",
                self.subscriptions.pending_subscribe_topics()
            )
        })
    }

    /// Gets a bar type from the cache by coin and interval.
    ///
    /// This looks up the subscription key created when subscribing to bars.
    pub fn get_bar_type(&self, coin: &str, interval: &str) -> Option<BarType> {
        // Use canonical key format matching subscribe_bars
        let key = format!("candle:{coin}:{interval}");
        self.bar_types.load().get(&key).copied()
    }

    /// Subscribe to L2 order book for an instrument.
    pub async fn subscribe_book(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        self.subscribe_book_with_options(instrument_id, None, None)
            .await
    }

    /// Subscribe to L2 order book with optional `nSigFigs` / `mantissa`
    /// precision controls passed through to the venue's `l2Book` stream.
    ///
    /// One venue `l2Book` stream per coin is shared with depth snapshots;
    /// the first logical use opens the stream and its options win. Requesting
    /// different options while the stream is active logs a warning.
    pub async fn subscribe_book_with_options(
        &self,
        instrument_id: InstrumentId,
        n_sig_figs: Option<u32>,
        mantissa: Option<u32>,
    ) -> anyhow::Result<()> {
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();

        let cmd_tx = self.cmd_tx.read().await;

        // Update the handler's coin→instrument mapping for this subscription
        cmd_tx
            .send(HandlerCommand::UpdateInstrument(instrument.clone()))
            .map_err(|e| anyhow::anyhow!("Failed to send UpdateInstrument command: {e}"))?;

        self.send_book_stream_subscribe(&cmd_tx, coin, BookStreamUse::Deltas, n_sig_figs, mantissa)
    }

    /// Subscribes the coin's `l2Book` stream for order book deltas, opening `gate` once the
    /// subscription is written.
    ///
    /// A stream already open for depth snapshots is replaced so the book starts from a fresh
    /// snapshot. Returns without registering when `cancel` has already fired, and stops waiting
    /// once it fires; a queued write still completes so the venue matches the registry.
    pub(crate) async fn subscribe_book_gated(
        &self,
        instrument_id: InstrumentId,
        n_sig_figs: Option<u32>,
        mantissa: Option<u32>,
        cancel: CancellationToken,
        gate: SnapshotGate,
    ) -> Result<(), HyperliquidWsError> {
        let Some(instrument) = self.get_instrument(&instrument_id) else {
            let message = InstrumentLookupError::not_found(instrument_id).to_string();
            return Err(HyperliquidWsError::ClientError(message));
        };

        let coin = instrument.raw_symbol().inner();
        let (completion, receiver) = tokio::sync::oneshot::channel();
        let cmd_tx = self.cmd_tx.read().await;

        if cancel.is_cancelled() {
            return Ok(());
        }

        cmd_tx
            .send(HandlerCommand::UpdateInstrument(instrument))
            .map_err(|e| HyperliquidWsError::ChannelSend(e.to_string()))?;

        let registration =
            self.register_book_stream(coin, BookStreamUse::Deltas, n_sig_figs, mantissa);

        let subscription = SubscriptionRequest::L2Book {
            coin,
            mantissa: registration.options.mantissa,
            n_sig_figs: registration.options.n_sig_figs,
        };

        let replace = !registration.subscribe;
        let write_cancel = cancel.clone();

        let write = move |subscription| HandlerCommand::WriteBook {
            subscription,
            replace,
            cancel: write_cancel,
            gate,
            completion,
        };

        let sent = if registration.subscribe {
            self.send_reserved_command(&cmd_tx, subscription, write)
        } else {
            cmd_tx
                .send(write(subscription))
                .map_err(|e| anyhow::anyhow!("Failed to send book write command: {e}"))
        };

        if let Err(e) = sent {
            if registration.subscribe {
                self.book_streams.release(&coin, BookStreamUse::Deltas);
            }

            return Err(HyperliquidWsError::ChannelSend(e.to_string()));
        }

        drop(cmd_tx);

        tokio::select! {
            biased;
            () = cancel.cancelled() => Ok(()),
            result = receiver => result.map_err(|e| HyperliquidWsError::ChannelSend(e.to_string()))?,
        }
    }

    /// Subscribe to order book depth-10 snapshots.
    ///
    /// Reuses the same `l2Book` WebSocket subscription as
    /// [`Self::subscribe_book`] and flags the handler to additionally emit
    /// `NautilusWsMessage::Depth` for this coin.
    pub async fn subscribe_book_depth(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        self.subscribe_book_depth_with_options(instrument_id, None, None)
            .await
    }

    /// Subscribe to depth-10 snapshots with optional `nSigFigs` /
    /// `mantissa` precision controls.
    ///
    /// Shares the coin's `l2Book` stream with deltas subscribers; the first
    /// logical use opens the stream and its options win. Requesting different
    /// options while the stream is active logs a warning.
    pub async fn subscribe_book_depth_with_options(
        &self,
        instrument_id: InstrumentId,
        n_sig_figs: Option<u32>,
        mantissa: Option<u32>,
    ) -> anyhow::Result<()> {
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();

        let cmd_tx = self.cmd_tx.read().await;

        cmd_tx
            .send(HandlerCommand::UpdateInstrument(instrument.clone()))
            .map_err(|e| anyhow::anyhow!("Failed to send UpdateInstrument command: {e}"))?;

        cmd_tx
            .send(HandlerCommand::SetDepthSub {
                coin,
                subscribed: true,
            })
            .map_err(|e| anyhow::anyhow!("Failed to send SetDepthSub command: {e}"))?;

        self.send_book_stream_subscribe(&cmd_tx, coin, BookStreamUse::Depth, n_sig_figs, mantissa)
    }

    /// Unsubscribe from order book depth-10 snapshots.
    ///
    /// Clears the depth emission flag and tears down the underlying
    /// `l2Book` stream unless active deltas subscribers still need it.
    pub async fn unsubscribe_book_depth(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();

        let cmd_tx = self.cmd_tx.read().await;

        cmd_tx
            .send(HandlerCommand::SetDepthSub {
                coin,
                subscribed: false,
            })
            .map_err(|e| anyhow::anyhow!("Failed to send SetDepthSub command: {e}"))?;

        self.send_book_stream_unsubscribe(&cmd_tx, coin, BookStreamUse::Depth)
    }

    /// Subscribe to best bid/offer (BBO) quotes for an instrument.
    pub async fn subscribe_quotes(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();

        let cmd_tx = self.cmd_tx.read().await;
        self.quote_streams.insert(coin, ());

        // Update the handler's coin→instrument mapping for this subscription
        if let Err(e) = cmd_tx.send(HandlerCommand::UpdateInstrument(instrument.clone())) {
            self.quote_streams.remove(&coin);
            anyhow::bail!("Failed to send UpdateInstrument command: {e}");
        }

        let subscription = SubscriptionRequest::Bbo { coin };

        if let Err(e) = self.send_subscription(&cmd_tx, subscription) {
            self.quote_streams.remove(&coin);
            return Err(e);
        }
        Ok(())
    }

    /// Subscribe to all mid prices across markets.
    pub async fn subscribe_all_mids(&self) -> anyhow::Result<()> {
        self.subscribe_all_mids_with_dex(None).await
    }

    /// Subscribe to aggregate asset contexts across all perp dexes.
    pub async fn subscribe_all_dexs_asset_ctxs(&self) -> anyhow::Result<()> {
        self.send_subscription(
            &*self.cmd_tx.read().await,
            SubscriptionRequest::AllDexsAssetCtxs,
        )?;
        Ok(())
    }

    /// Subscribe to all mid prices across markets, optionally scoped to a specific dex.
    pub async fn subscribe_all_mids_with_dex(&self, dex: Option<&str>) -> anyhow::Result<()> {
        let cmd_tx = self.cmd_tx.read().await;

        let subscription = SubscriptionRequest::AllMids {
            dex: dex.map(ToString::to_string),
        };

        self.send_subscription(&cmd_tx, subscription)?;
        Ok(())
    }

    /// Unsubscribe from all mid prices across markets.
    pub async fn unsubscribe_all_mids(&self) -> anyhow::Result<()> {
        self.unsubscribe_all_mids_with_dex(None).await
    }

    /// Unsubscribe from aggregate asset contexts across all perp dexes.
    pub async fn unsubscribe_all_dexs_asset_ctxs(&self) -> anyhow::Result<()> {
        self.send_unsubscription(
            &*self.cmd_tx.read().await,
            SubscriptionRequest::AllDexsAssetCtxs,
        )?;
        Ok(())
    }

    /// Unsubscribe from all mid prices across markets, optionally scoped to a specific dex.
    pub async fn unsubscribe_all_mids_with_dex(&self, dex: Option<&str>) -> anyhow::Result<()> {
        let cmd_tx = self.cmd_tx.read().await;

        let subscription = SubscriptionRequest::AllMids {
            dex: dex.map(ToString::to_string),
        };

        self.send_unsubscription(&cmd_tx, subscription)?;
        Ok(())
    }

    /// Subscribe to trades for an instrument.
    pub async fn subscribe_trades(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        self.subscribe_trade_stream(instrument_id, TradeStreamUse::Ticks)
            .await
    }

    /// Subscribe to complete public trades for an instrument.
    pub async fn subscribe_public_trades(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        self.subscribe_trade_stream(instrument_id, TradeStreamUse::PublicTrades)
            .await
    }

    async fn subscribe_trade_stream(
        &self,
        instrument_id: InstrumentId,
        stream_use: TradeStreamUse,
    ) -> anyhow::Result<()> {
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();

        let cmd_tx = self.cmd_tx.read().await;

        // Update the handler's coin→instrument mapping for this subscription
        cmd_tx
            .send(HandlerCommand::UpdateInstrument(instrument.clone()))
            .map_err(|e| anyhow::anyhow!("Failed to send UpdateInstrument command: {e}"))?;

        // Keep registry mutations and their handler commands ordered across
        // concurrent generic/custom subscriptions for the same coin.
        let _trade_stream_guard = self.trade_stream_lock.lock();
        let registration = self.trade_streams.register(coin, stream_use);
        cmd_tx
            .send(HandlerCommand::UpdateTradeSubs {
                coin,
                uses: registration.uses,
            })
            .map_err(|e| anyhow::anyhow!("Failed to send UpdateTradeSubs command: {e}"))?;

        if registration.subscribe
            && let Err(e) = self.send_subscription(&cmd_tx, SubscriptionRequest::Trades { coin })
        {
            let rollback = self.trade_streams.release(&coin, stream_use);
            let _ = cmd_tx.send(HandlerCommand::UpdateTradeSubs {
                coin,
                uses: rollback.uses,
            });
            return Err(e);
        }
        Ok(())
    }

    /// Subscribe to mark price updates for an instrument.
    pub async fn subscribe_mark_prices(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        self.subscribe_asset_context_data(instrument_id, AssetContextDataType::MarkPrice)
            .await
    }

    /// Subscribe to index/oracle price updates for an instrument.
    pub async fn subscribe_index_prices(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        self.subscribe_asset_context_data(instrument_id, AssetContextDataType::IndexPrice)
            .await
    }

    /// Subscribe to candle/bar data for a specific coin and interval.
    pub async fn subscribe_bars(&self, bar_type: BarType) -> anyhow::Result<()> {
        let instrument_id = bar_type.instrument_id();
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();
        let interval = bar_type_to_interval(&bar_type)?;
        let subscription = SubscriptionRequest::Candle { coin, interval };

        // Cache the bar type for parsing using canonical key
        let key = format!("candle:{coin}:{interval}");
        self.bar_types.insert(key.clone(), bar_type);

        let cmd_tx = self.cmd_tx.read().await;

        cmd_tx
            .send(HandlerCommand::UpdateInstrument(instrument.clone()))
            .map_err(|e| anyhow::anyhow!("Failed to send UpdateInstrument command: {e}"))?;

        cmd_tx
            .send(HandlerCommand::AddBarType {
                key: key.clone(),
                bar_type,
            })
            .map_err(|e| anyhow::anyhow!("Failed to send AddBarType command: {e}"))?;

        if let Err(e) = self.send_subscription(&cmd_tx, subscription) {
            self.bar_types.remove(&key);
            let _ = cmd_tx.send(HandlerCommand::RemoveBarType { key });
            return Err(e);
        }
        Ok(())
    }

    /// Subscribe to funding rate updates for an instrument.
    pub async fn subscribe_funding_rates(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        self.subscribe_asset_context_data(instrument_id, AssetContextDataType::FundingRate)
            .await
    }

    /// Subscribe to open interest updates for an instrument.
    pub async fn subscribe_open_interest(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        self.subscribe_asset_context_data(instrument_id, AssetContextDataType::OpenInterest)
            .await
    }

    /// Subscribe to order updates for a specific user address.
    pub async fn subscribe_order_updates(&self, user: &str) -> anyhow::Result<()> {
        let subscription = SubscriptionRequest::OrderUpdates {
            user: user.to_string(),
        };
        self.send_subscription(&*self.cmd_tx.read().await, subscription)?;
        Ok(())
    }

    /// Subscribe to user events (fills, funding, liquidations) for a specific user address.
    pub async fn subscribe_user_events(&self, user: &str) -> anyhow::Result<()> {
        let subscription = SubscriptionRequest::UserEvents {
            user: user.to_string(),
        };
        self.send_subscription(&*self.cmd_tx.read().await, subscription)?;
        Ok(())
    }

    /// Subscribe to user fills for a specific user address.
    ///
    /// Note: This channel is redundant with `userEvents` which already includes fills.
    /// Prefer using `subscribe_user_events` or `subscribe_all_user_channels` instead.
    pub async fn subscribe_user_fills(&self, user: &str) -> anyhow::Result<()> {
        let subscription = SubscriptionRequest::UserFills {
            user: user.to_string(),
            aggregate_by_time: None,
        };
        self.send_subscription(&*self.cmd_tx.read().await, subscription)?;
        Ok(())
    }

    /// Subscribe to all user channels (order updates + user events) for convenience.
    ///
    /// Note: `userEvents` already includes fills, so we don't subscribe to `userFills`
    /// separately to avoid duplicate fill messages.
    ///
    /// This does **not** include opt-in TWAP custom-data channels
    /// (`userTwapHistory` / `userTwapSliceFills`).
    pub async fn subscribe_all_user_channels(&self, user: &str) -> anyhow::Result<()> {
        self.subscribe_order_updates(user).await?;
        self.subscribe_user_events(user).await?;
        Ok(())
    }

    /// Subscribe to TWAP history for a user address (`userTwapHistory`).
    ///
    /// Opt-in custom data. The address need not be the adapter trading account.
    pub async fn subscribe_user_twap_history(&self, user: &str) -> anyhow::Result<()> {
        let subscription = SubscriptionRequest::UserTwapHistory {
            user: user.to_string(),
        };
        self.send_subscription(&*self.cmd_tx.read().await, subscription)?;
        Ok(())
    }

    /// Unsubscribe from TWAP history for a user address.
    pub async fn unsubscribe_user_twap_history(&self, user: &str) -> anyhow::Result<()> {
        let subscription = SubscriptionRequest::UserTwapHistory {
            user: user.to_string(),
        };
        self.send_unsubscription(&*self.cmd_tx.read().await, subscription)?;
        Ok(())
    }

    /// Subscribe to TWAP slice fills for a user address (`userTwapSliceFills`).
    ///
    /// Opt-in custom data. The address need not be the adapter trading account.
    pub async fn subscribe_user_twap_slice_fills(&self, user: &str) -> anyhow::Result<()> {
        let subscription = SubscriptionRequest::UserTwapSliceFills {
            user: user.to_string(),
        };
        self.send_subscription(&*self.cmd_tx.read().await, subscription)?;
        Ok(())
    }

    /// Unsubscribe from TWAP slice fills for a user address.
    pub async fn unsubscribe_user_twap_slice_fills(&self, user: &str) -> anyhow::Result<()> {
        let subscription = SubscriptionRequest::UserTwapSliceFills {
            user: user.to_string(),
        };
        self.send_unsubscription(&*self.cmd_tx.read().await, subscription)?;
        Ok(())
    }

    /// Unsubscribe from L2 order book for an instrument.
    ///
    /// Tears down the venue `l2Book` stream unless active depth subscribers
    /// still need it.
    pub async fn unsubscribe_book(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();

        let cmd_tx = self.cmd_tx.read().await;

        self.send_book_stream_unsubscribe(&cmd_tx, coin, BookStreamUse::Deltas)
    }

    /// Resubscribes the venue `l2Book` stream for an instrument in place.
    ///
    /// Sends an unsubscribe immediately followed by a subscribe, both echoing
    /// the stream's original precision options (the venue matches unsubscribes
    /// by full payload). Registry state is left untouched so the logical
    /// deltas/depth uses and first-wins options survive the cycle. Used by
    /// stale-stream recovery, where a plain subscribe would be gated off by
    /// the existing registry entry.
    pub async fn resubscribe_book(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();

        // Serialize the registry check with read-locked subscribe/unsubscribe senders
        let cmd_tx = self.cmd_tx.write().await;

        let Some(options) = self.book_streams.options(&coin) else {
            log::debug!("Skipping l2Book resubscribe for {coin}: stream no longer registered");
            return Ok(());
        };

        let subscription = SubscriptionRequest::L2Book {
            coin,
            mantissa: options.mantissa,
            n_sig_figs: options.n_sig_figs,
        };

        self.send_stream_resubscribe(&cmd_tx, subscription)
    }

    /// Replaces the coin's `l2Book` subscription to request a fresh snapshot, opening `gate`
    /// once the subscription is written.
    ///
    /// Echoes the stream's original precision options and leaves registry state untouched, as
    /// [`Self::resubscribe_book`] does.
    pub(crate) async fn resubscribe_book_gated(
        &self,
        instrument_id: InstrumentId,
        cancel: CancellationToken,
        gate: SnapshotGate,
    ) -> Result<(), HyperliquidWsError> {
        let Some(instrument) = self.get_instrument(&instrument_id) else {
            let message = InstrumentLookupError::not_found(instrument_id).to_string();
            return Err(HyperliquidWsError::ClientError(message));
        };

        let coin = instrument.raw_symbol().inner();
        let (completion, receiver) = tokio::sync::oneshot::channel();

        // Serialize the registry check with read-locked subscribe/unsubscribe senders
        let cmd_tx = self.cmd_tx.write().await;

        if cancel.is_cancelled() {
            return Err(HyperliquidWsError::ClientError(
                "Book recovery canceled".to_string(),
            ));
        }

        let Some(options) = self.book_streams.options(&coin) else {
            return Err(HyperliquidWsError::ClientError(format!(
                "l2Book stream for {coin} is no longer registered"
            )));
        };

        let subscription = SubscriptionRequest::L2Book {
            coin,
            mantissa: options.mantissa,
            n_sig_figs: options.n_sig_figs,
        };

        cmd_tx
            .send(HandlerCommand::WriteBook {
                subscription,
                replace: true,
                cancel,
                gate,
                completion,
            })
            .map_err(|e| HyperliquidWsError::ChannelSend(e.to_string()))?;

        drop(cmd_tx);

        receiver
            .await
            .map_err(|e| HyperliquidWsError::ChannelSend(e.to_string()))?
    }

    fn send_book_stream_subscribe(
        &self,
        cmd_tx: &tokio::sync::mpsc::UnboundedSender<HandlerCommand>,
        coin: Ustr,
        stream_use: BookStreamUse,
        n_sig_figs: Option<u32>,
        mantissa: Option<u32>,
    ) -> anyhow::Result<()> {
        let registration = self.register_book_stream(coin, stream_use, n_sig_figs, mantissa);

        if registration.subscribe {
            let subscription = SubscriptionRequest::L2Book {
                coin,
                mantissa: registration.options.mantissa,
                n_sig_figs: registration.options.n_sig_figs,
            };

            if let Err(e) = self.send_subscription(cmd_tx, subscription) {
                self.book_streams.release(&coin, stream_use);
                return Err(e);
            }
        }

        Ok(())
    }

    fn register_book_stream(
        &self,
        coin: Ustr,
        stream_use: BookStreamUse,
        n_sig_figs: Option<u32>,
        mantissa: Option<u32>,
    ) -> BookStreamRegistration {
        let registration = self.book_streams.register(
            coin,
            stream_use,
            BookStreamOptions {
                n_sig_figs,
                mantissa,
            },
        );

        if registration.options_mismatch {
            log::warn!(
                "Requested l2Book options for {coin} (n_sig_figs={n_sig_figs:?}, mantissa={mantissa:?}) \
                differ from the active stream ({:?}), keeping active options",
                registration.options,
            );
        }

        registration
    }

    fn send_book_stream_unsubscribe(
        &self,
        cmd_tx: &tokio::sync::mpsc::UnboundedSender<HandlerCommand>,
        coin: Ustr,
        stream_use: BookStreamUse,
    ) -> anyhow::Result<()> {
        match self.book_streams.release(&coin, stream_use) {
            BookStreamRelease::Unsubscribe(options) => {
                let subscription = SubscriptionRequest::L2Book {
                    coin,
                    mantissa: options.mantissa,
                    n_sig_figs: options.n_sig_figs,
                };

                self.send_unsubscription(cmd_tx, subscription)?;
            }
            BookStreamRelease::Retained => {
                let remaining_use = match stream_use {
                    BookStreamUse::Deltas => "depth",
                    BookStreamUse::Depth => "deltas",
                };
                log::debug!("Keeping shared l2Book stream for {coin}: {remaining_use} use remains");
            }
        }
        Ok(())
    }

    /// Unsubscribe from quote ticks for an instrument.
    pub async fn unsubscribe_quotes(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();

        let subscription = SubscriptionRequest::Bbo { coin };
        let cmd_tx = self.cmd_tx.read().await;

        self.quote_streams.remove(&coin);

        self.send_unsubscription(&cmd_tx, subscription)?;
        Ok(())
    }

    /// Resubscribes the venue `bbo` stream for an instrument in place
    /// (unsubscribe immediately followed by subscribe). Used by stale-stream
    /// recovery.
    pub async fn resubscribe_quotes(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();

        // Keep the registration check atomic with the resubscribe pair
        let cmd_tx = self.cmd_tx.write().await;

        if !self.quote_streams.contains_key(&coin) {
            log::debug!("Skipping bbo resubscribe for {coin}: stream no longer registered");
            return Ok(());
        }

        self.send_stream_resubscribe(&cmd_tx, SubscriptionRequest::Bbo { coin })
    }

    fn send_stream_resubscribe(
        &self,
        cmd_tx: &tokio::sync::mpsc::UnboundedSender<HandlerCommand>,
        subscription: SubscriptionRequest,
    ) -> anyhow::Result<()> {
        cmd_tx
            .send(HandlerCommand::Resubscribe { subscription })
            .map_err(|e| anyhow::anyhow!("Failed to send resubscribe command: {e}"))
    }

    /// Unsubscribe from trades for an instrument.
    pub async fn unsubscribe_trades(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        self.unsubscribe_trade_stream(instrument_id, TradeStreamUse::Ticks)
            .await
    }

    /// Unsubscribe from complete public trades for an instrument.
    pub async fn unsubscribe_public_trades(
        &self,
        instrument_id: InstrumentId,
    ) -> anyhow::Result<()> {
        self.unsubscribe_trade_stream(instrument_id, TradeStreamUse::PublicTrades)
            .await
    }

    async fn unsubscribe_trade_stream(
        &self,
        instrument_id: InstrumentId,
        stream_use: TradeStreamUse,
    ) -> anyhow::Result<()> {
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();

        let cmd_tx = self.cmd_tx.read().await;
        // Keep registry mutations and their handler commands ordered across
        // concurrent generic/custom unsubscriptions for the same coin.
        let _trade_stream_guard = self.trade_stream_lock.lock();
        let release = self.trade_streams.release(&coin, stream_use);
        cmd_tx
            .send(HandlerCommand::UpdateTradeSubs {
                coin,
                uses: release.uses,
            })
            .map_err(|e| anyhow::anyhow!("Failed to send UpdateTradeSubs command: {e}"))?;

        if release.unsubscribe {
            self.send_unsubscription(&cmd_tx, SubscriptionRequest::Trades { coin })?;
        }
        Ok(())
    }

    /// Unsubscribe from mark price updates for an instrument.
    pub async fn unsubscribe_mark_prices(&self, instrument_id: InstrumentId) -> anyhow::Result<()> {
        self.unsubscribe_asset_context_data(instrument_id, AssetContextDataType::MarkPrice)
            .await
    }

    /// Unsubscribe from index/oracle price updates for an instrument.
    pub async fn unsubscribe_index_prices(
        &self,
        instrument_id: InstrumentId,
    ) -> anyhow::Result<()> {
        self.unsubscribe_asset_context_data(instrument_id, AssetContextDataType::IndexPrice)
            .await
    }

    /// Unsubscribe from candle/bar data.
    pub async fn unsubscribe_bars(&self, bar_type: BarType) -> anyhow::Result<()> {
        let instrument_id = bar_type.instrument_id();
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();
        let interval = bar_type_to_interval(&bar_type)?;
        let subscription = SubscriptionRequest::Candle { coin, interval };

        let key = format!("candle:{coin}:{interval}");
        self.bar_types.remove(&key);

        let cmd_tx = self.cmd_tx.read().await;

        cmd_tx
            .send(HandlerCommand::RemoveBarType { key })
            .map_err(|e| anyhow::anyhow!("Failed to send RemoveBarType command: {e}"))?;

        self.send_unsubscription(&cmd_tx, subscription)?;
        Ok(())
    }

    /// Unsubscribe from funding rate updates for an instrument.
    pub async fn unsubscribe_funding_rates(
        &self,
        instrument_id: InstrumentId,
    ) -> anyhow::Result<()> {
        self.unsubscribe_asset_context_data(instrument_id, AssetContextDataType::FundingRate)
            .await
    }

    /// Unsubscribe from open interest updates for an instrument.
    pub async fn unsubscribe_open_interest(
        &self,
        instrument_id: InstrumentId,
    ) -> anyhow::Result<()> {
        self.unsubscribe_asset_context_data(instrument_id, AssetContextDataType::OpenInterest)
            .await
    }

    /// Cache the ordered instrument IDs required to normalize `allDexsAssetCtxs`.
    ///
    /// Entries merge by dex: each dex in `mapping` replaces its cached entry and
    /// dexes absent from `mapping` keep theirs. A mapping built from the
    /// standard `meta` fallback covers only the standard dex, and replacing the
    /// whole cache with it would drop every HIP-3 context until a later complete
    /// build. A stale entry for a dex the venue no longer lists is harmless
    /// because no contexts arrive for it.
    pub fn cache_all_dex_asset_ctxs_instrument_ids(
        &self,
        mapping: AHashMap<Ustr, Vec<Option<InstrumentId>>>,
    ) {
        let cmd_tx = self.cache_tx.lock();
        self.all_dex_asset_ctxs_instrument_ids.rcu(|cached| {
            cached.extend(mapping.iter().map(|(dex, ids)| (*dex, ids.clone())));
        });

        if let Err(e) = cmd_tx.send(HandlerCommand::CacheAllDexAssetCtxsInstrumentIds(mapping)) {
            log::debug!(
                "Failed to send CacheAllDexAssetCtxsInstrumentIds command (handler may not be connected yet): {e}"
            );
        }
    }

    async fn subscribe_asset_context_data(
        &self,
        instrument_id: InstrumentId,
        data_type: AssetContextDataType,
    ) -> anyhow::Result<()> {
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();

        let mut entry = self.asset_context_subs.entry(coin).or_default();
        let is_first_subscription = entry.is_empty();
        entry.insert(data_type);
        let data_types = entry.clone();
        drop(entry);

        let cmd_tx = self.cmd_tx.read().await;

        cmd_tx
            .send(HandlerCommand::UpdateAssetContextSubs { coin, data_types })
            .map_err(|e| anyhow::anyhow!("Failed to send UpdateAssetContextSubs command: {e}"))?;

        if is_first_subscription {
            log::debug!(
                "First asset context subscription for coin '{coin}', subscribing to ActiveAssetCtx"
            );
            let subscription = SubscriptionRequest::ActiveAssetCtx { coin };

            cmd_tx
                .send(HandlerCommand::UpdateInstrument(instrument.clone()))
                .map_err(|e| anyhow::anyhow!("Failed to send UpdateInstrument command: {e}"))?;

            if let Err(e) = self.send_subscription(&cmd_tx, subscription) {
                if let Some(mut entry) = self.asset_context_subs.get_mut(&coin) {
                    entry.remove(&data_type);
                    let rollback = entry.clone();
                    let remove_entry = entry.is_empty();
                    drop(entry);

                    if remove_entry {
                        self.asset_context_subs.remove(&coin);
                    }
                    let _ = cmd_tx.send(HandlerCommand::UpdateAssetContextSubs {
                        coin,
                        data_types: rollback,
                    });
                }
                return Err(e);
            }
        } else {
            log::debug!(
                "Already subscribed to ActiveAssetCtx for coin '{coin}', adding {data_type:?} to tracked types"
            );
        }

        Ok(())
    }

    async fn unsubscribe_asset_context_data(
        &self,
        instrument_id: InstrumentId,
        data_type: AssetContextDataType,
    ) -> anyhow::Result<()> {
        let instrument = self
            .get_instrument(&instrument_id)
            .ok_or_else(|| InstrumentLookupError::not_found(instrument_id))?;
        let coin = instrument.raw_symbol().inner();

        if let Some(mut entry) = self.asset_context_subs.get_mut(&coin) {
            entry.remove(&data_type);
            let should_unsubscribe = entry.is_empty();
            let data_types = entry.clone();
            drop(entry);

            let cmd_tx = self.cmd_tx.read().await;

            if should_unsubscribe {
                self.asset_context_subs.remove(&coin);

                log::debug!(
                    "Last asset context subscription removed for coin '{coin}', unsubscribing from ActiveAssetCtx"
                );
                let subscription = SubscriptionRequest::ActiveAssetCtx { coin };

                cmd_tx
                    .send(HandlerCommand::UpdateAssetContextSubs {
                        coin,
                        data_types: AHashSet::new(),
                    })
                    .map_err(|e| {
                        anyhow::anyhow!("Failed to send UpdateAssetContextSubs command: {e}")
                    })?;

                self.send_unsubscription(&cmd_tx, subscription)?;
            } else {
                log::debug!(
                    "Removed {data_type:?} from tracked types for coin '{coin}', but keeping ActiveAssetCtx subscription"
                );

                cmd_tx
                    .send(HandlerCommand::UpdateAssetContextSubs { coin, data_types })
                    .map_err(|e| {
                        anyhow::anyhow!("Failed to send UpdateAssetContextSubs command: {e}")
                    })?;
            }
        }

        Ok(())
    }

    fn send_subscription(
        &self,
        cmd_tx: &tokio::sync::mpsc::UnboundedSender<HandlerCommand>,
        subscription: SubscriptionRequest,
    ) -> anyhow::Result<()> {
        self.send_reserved_command(cmd_tx, subscription, |subscription| {
            HandlerCommand::Subscribe {
                subscriptions: vec![subscription],
            }
        })
    }

    fn send_reserved_command(
        &self,
        cmd_tx: &tokio::sync::mpsc::UnboundedSender<HandlerCommand>,
        subscription: SubscriptionRequest,
        command: impl FnOnce(SubscriptionRequest) -> HandlerCommand,
    ) -> anyhow::Result<()> {
        let key = crate::websocket::handler::subscription_to_key(&subscription);
        let reserved = self
            .rate_limits
            .reserve_subscription(self.client_id, &subscription)
            .map_err(anyhow::Error::msg)?;

        if let Err(e) = cmd_tx.send(command(subscription)) {
            if reserved {
                self.rate_limits.release_subscription(self.client_id, &key);
            }
            anyhow::bail!("Failed to send subscribe command: {e}");
        }
        Ok(())
    }

    fn send_unsubscription(
        &self,
        cmd_tx: &tokio::sync::mpsc::UnboundedSender<HandlerCommand>,
        subscription: SubscriptionRequest,
    ) -> anyhow::Result<()> {
        cmd_tx
            .send(HandlerCommand::Unsubscribe {
                subscriptions: vec![subscription],
            })
            .map_err(|e| anyhow::anyhow!("Failed to send unsubscribe command: {e}"))
    }

    /// Receives the next message from the WebSocket handler.
    ///
    /// Returns `None` if the handler has disconnected or the receiver was already taken.
    pub async fn next_event(&mut self) -> Option<NautilusWsMessage> {
        if let Some(ref mut rx) = self.out_rx {
            rx.recv().await
        } else {
            None
        }
    }

    fn release_limit_reservations(&self) {
        self.rate_limits.release_client(self.client_id);
        self.connection_permit.lock().take();
    }
}

impl Drop for HyperliquidWebSocketClient {
    fn drop(&mut self) {
        if Arc::strong_count(&self.task_handle) == 1 {
            self.release_limit_reservations();

            if self.task_handle.is_empty() {
                return;
            }

            self.signal.store(true, Ordering::Relaxed);
            self.task_handle.abort();

            if let Some(control) = &self.socket_control {
                control.deregister();
            }
        }
    }
}

#[derive(Debug)]
pub(crate) enum PostRequestError {
    BeforeDispatch(HyperliquidError),
    AfterDispatch(HyperliquidError),
    Rejected {
        error: HyperliquidError,
        reason: String,
    },
}

impl PostRequestError {
    fn into_error(self) -> HyperliquidError {
        match self {
            Self::BeforeDispatch(error)
            | Self::AfterDispatch(error)
            | Self::Rejected { error, .. } => error,
        }
    }
}

fn cancel_errors_for_requests(
    errors: Vec<Option<String>>,
    request_count: usize,
) -> HyperliquidResult<Vec<Option<String>>> {
    if errors.is_empty() {
        return Ok(vec![None; request_count]);
    }

    if errors.len() != request_count {
        return Err(HyperliquidError::exchange(format!(
            "Cancel orders returned {} statuses for {request_count} cancels",
            errors.len()
        )));
    }

    Ok(errors)
}

fn map_post_payload_error(payload: String, weight: u32) -> HyperliquidError {
    let lower = payload.to_ascii_lowercase();
    let message = format!("WebSocket post error: {payload}");

    if starts_with_status(&lower, &["429"])
        || lower.contains("too many requests")
        || lower.contains("rate limit")
    {
        HyperliquidError::rate_limit("exchange", weight, None)
    } else if starts_with_status(&lower, &["401", "403"])
        || lower.contains("unauthorized")
        || lower.contains("forbidden")
        || lower.contains("authentication")
        || lower.contains("authorization")
        || lower.contains("invalid signature")
        || contains_word(&lower, "auth")
    {
        HyperliquidError::auth(message)
    } else if starts_with_status(&lower, &["400"]) || lower.contains("bad request") {
        HyperliquidError::bad_request(message)
    } else if starts_with_status(&lower, &["500", "502", "503", "504"]) {
        HyperliquidError::exchange(message)
    } else {
        HyperliquidError::exchange(payload)
    }
}

fn hyperliquid_order_kind(
    order_type: OrderType,
    time_in_force: TimeInForce,
    post_only: bool,
    trigger_price: Option<Price>,
    normalize_prices_enabled: bool,
    price_precision: Option<u8>,
) -> HyperliquidResult<HyperliquidExchangeOrderKind> {
    match order_type {
        OrderType::Market => Ok(HyperliquidExchangeOrderKind::Limit {
            limit: HyperliquidExchangeLimitParams {
                tif: HyperliquidExchangeTif::Ioc,
            },
        }),
        OrderType::Limit => {
            let tif = time_in_force_to_hyperliquid_tif(time_in_force, post_only)
                .map_err(|e| HyperliquidError::bad_request(format!("{e}")))?;
            Ok(HyperliquidExchangeOrderKind::Limit {
                limit: HyperliquidExchangeLimitParams { tif },
            })
        }
        OrderType::StopMarket
        | OrderType::StopLimit
        | OrderType::MarketIfTouched
        | OrderType::LimitIfTouched => {
            let trigger_price = trigger_price.ok_or_else(|| {
                HyperliquidError::bad_request("Trigger orders require a trigger price")
            })?;
            let trigger_px = normalize_or_validate_wire_price(
                trigger_price.as_decimal(),
                "Trigger price",
                price_precision,
                normalize_prices_enabled,
            )
            .map_err(|e| HyperliquidError::bad_request(format!("{e}")))?;
            let tpsl = match order_type {
                OrderType::StopMarket | OrderType::StopLimit => HyperliquidExchangeTpSl::Sl,
                OrderType::MarketIfTouched | OrderType::LimitIfTouched => {
                    HyperliquidExchangeTpSl::Tp
                }
                _ => unreachable!(),
            };
            let is_market = matches!(
                order_type,
                OrderType::StopMarket | OrderType::MarketIfTouched
            );

            Ok(HyperliquidExchangeOrderKind::Trigger {
                trigger: HyperliquidExchangeTriggerParams {
                    is_market,
                    trigger_px,
                    tpsl,
                },
            })
        }
        _ => Err(HyperliquidError::bad_request(format!(
            "Order type {order_type:?} not supported"
        ))),
    }
}

fn ensure_ws_action_accepted(
    response: &HyperliquidExchangeResponse,
    action_name: &str,
) -> HyperliquidResult<()> {
    if response.is_ok() {
        if let Some(error_msg) = extract_inner_errors(response).into_iter().flatten().next() {
            return Err(HyperliquidError::bad_request(format!(
                "{action_name} rejected: {error_msg}"
            )));
        }

        if let Some(error_msg) = extract_inner_error(response) {
            return Err(HyperliquidError::bad_request(format!(
                "{action_name} rejected: {error_msg}"
            )));
        }

        return Ok(());
    }

    Err(HyperliquidError::bad_request(format!(
        "{action_name} failed: {}",
        extract_error_message(response)
    )))
}

fn starts_with_status(payload: &str, statuses: &[&str]) -> bool {
    let trimmed = payload.trim_start();
    statuses
        .iter()
        .any(|status| starts_with_status_token(trimmed, status))
        || trimmed.strip_prefix("http").is_some_and(|rest| {
            let rest = rest
                .trim_start_matches(|c: char| c.is_ascii_whitespace() || matches!(c, ':' | '/'));
            statuses
                .iter()
                .any(|status| starts_with_status_token(rest, status))
        })
}

fn starts_with_status_token(payload: &str, status: &str) -> bool {
    payload.strip_prefix(status).is_some_and(|rest| {
        rest.chars()
            .next()
            .is_none_or(|c| !c.is_ascii_alphanumeric())
    })
}

fn contains_word(payload: &str, word: &str) -> bool {
    payload
        .split(|c: char| !c.is_ascii_alphanumeric())
        .any(|part| part == word)
}

// Uses split_once/rsplit_once because coin names can contain colons
// (e.g., vault tokens `vntls:vCURSOR`)
fn subscription_from_topic(topic: &str) -> anyhow::Result<SubscriptionRequest> {
    let (kind, rest) = topic
        .split_once(':')
        .map_or((topic, None), |(k, r)| (k, Some(r)));

    let channel = HyperliquidWsChannel::from_wire_str(kind)
        .ok_or_else(|| anyhow::anyhow!("Unknown subscription channel: {kind}"))?;

    match channel {
        HyperliquidWsChannel::AllMids => Ok(SubscriptionRequest::AllMids {
            dex: rest.map(|s| s.to_string()),
        }),
        HyperliquidWsChannel::AllDexsAssetCtxs => Ok(SubscriptionRequest::AllDexsAssetCtxs),
        HyperliquidWsChannel::Notification => Ok(SubscriptionRequest::Notification {
            user: rest.context("Missing user")?.to_string(),
        }),
        HyperliquidWsChannel::WebData2 => Ok(SubscriptionRequest::WebData2 {
            user: rest.context("Missing user")?.to_string(),
        }),
        HyperliquidWsChannel::Candle => {
            // Format: candle:{coin}:{interval} - interval is last segment
            let rest = rest.context("Missing candle params")?;
            let (coin, interval_str) = rest.rsplit_once(':').context("Missing interval")?;
            let interval = HyperliquidBarInterval::from_str(interval_str)?;
            Ok(SubscriptionRequest::Candle {
                coin: Ustr::from(coin),
                interval,
            })
        }
        HyperliquidWsChannel::L2Book => Ok(SubscriptionRequest::L2Book {
            coin: Ustr::from(rest.context("Missing coin")?),
            mantissa: None,
            n_sig_figs: None,
        }),
        HyperliquidWsChannel::Trades => Ok(SubscriptionRequest::Trades {
            coin: Ustr::from(rest.context("Missing coin")?),
        }),
        HyperliquidWsChannel::OrderUpdates => Ok(SubscriptionRequest::OrderUpdates {
            user: rest.context("Missing user")?.to_string(),
        }),
        HyperliquidWsChannel::UserEvents => Ok(SubscriptionRequest::UserEvents {
            user: rest.context("Missing user")?.to_string(),
        }),
        HyperliquidWsChannel::UserFills => Ok(SubscriptionRequest::UserFills {
            user: rest.context("Missing user")?.to_string(),
            aggregate_by_time: None,
        }),
        HyperliquidWsChannel::UserFundings => Ok(SubscriptionRequest::UserFundings {
            user: rest.context("Missing user")?.to_string(),
        }),
        HyperliquidWsChannel::UserNonFundingLedgerUpdates => {
            Ok(SubscriptionRequest::UserNonFundingLedgerUpdates {
                user: rest.context("Missing user")?.to_string(),
            })
        }
        HyperliquidWsChannel::ActiveAssetCtx => Ok(SubscriptionRequest::ActiveAssetCtx {
            coin: Ustr::from(rest.context("Missing coin")?),
        }),
        HyperliquidWsChannel::ActiveSpotAssetCtx => Ok(SubscriptionRequest::ActiveSpotAssetCtx {
            coin: Ustr::from(rest.context("Missing coin")?),
        }),
        HyperliquidWsChannel::ActiveAssetData => {
            // Format: activeAssetData:{user}:{coin} - user is eth addr (no colons)
            let rest = rest.context("Missing params")?;
            let (user, coin) = rest.split_once(':').context("Missing coin")?;
            Ok(SubscriptionRequest::ActiveAssetData {
                user: user.to_string(),
                coin: coin.to_string(),
            })
        }
        HyperliquidWsChannel::UserTwapSliceFills => Ok(SubscriptionRequest::UserTwapSliceFills {
            user: rest.context("Missing user")?.to_string(),
        }),
        HyperliquidWsChannel::UserTwapHistory => Ok(SubscriptionRequest::UserTwapHistory {
            user: rest.context("Missing user")?.to_string(),
        }),
        HyperliquidWsChannel::Bbo => Ok(SubscriptionRequest::Bbo {
            coin: Ustr::from(rest.context("Missing coin")?),
        }),

        // Response-only channels are not valid subscription topics
        HyperliquidWsChannel::SubscriptionResponse
        | HyperliquidWsChannel::User
        | HyperliquidWsChannel::Post
        | HyperliquidWsChannel::Pong
        | HyperliquidWsChannel::Error => {
            anyhow::bail!("Not a subscription channel: {kind}")
        }
    }
}

#[cfg(test)]
mod tests {
    use futures_util::StreamExt;
    use nautilus_live::{SocketReconnectRegistry, SocketReconnectRequestOutcome};
    use nautilus_model::{identifiers::ClientId, instruments::stubs::crypto_perpetual_ethusdt};
    use nautilus_network::mode::ReconnectRequestOutcome;
    use nautilus_testkit::connection::race_command_with_publication;
    use rstest::rstest;
    use ustr::Ustr;

    use super::*;
    use crate::{
        common::{
            consts::{HYPERLIQUID_WS_POST_INFLIGHT_MAX, HYPERLIQUID_WS_SUBSCRIPTIONS_MAX},
            enums::HyperliquidBarInterval,
        },
        websocket::handler::subscription_to_key,
    };

    #[tokio::test]
    async fn initialization_waits_for_acknowledgement() {
        let mut ws_client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let observer = ws_client.clone();
        let mode = Arc::new(AtomicU8::new(ConnectionMode::Active as u8));
        let (initialized_tx, initialized_rx) = tokio::sync::oneshot::channel();
        let mut initialization =
            Box::pin(ws_client.wait_for_initialization(initialized_rx, Arc::clone(&mode)));

        let polled =
            std::future::poll_fn(|cx| std::task::Poll::Ready(initialization.as_mut().poll(cx)))
                .await;
        assert!(polled.is_pending());
        assert!(!observer.is_active());

        initialized_tx.send(()).unwrap();
        initialization.await.unwrap();

        assert!(observer.is_active());
        assert!(Arc::ptr_eq(&observer.connection_mode.load_full(), &mode));
    }

    #[rstest]
    #[case::closed(false)]
    #[case::timeout(true)]
    #[tokio::test(start_paused = true)]
    async fn initialization_failure_releases_runtime(#[case] timeout: bool) {
        let mut ws_client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        ws_client.rate_limits = Arc::new(WebSocketRateLimits::new());
        let available = ws_client.rate_limits.connection_slots.available_permits();
        *ws_client.connection_permit.lock() = Some(
            Arc::clone(&ws_client.rate_limits.connection_slots)
                .try_acquire_owned()
                .unwrap(),
        );

        let (_out_tx, out_rx) = tokio::sync::mpsc::unbounded_channel();
        ws_client.out_rx = Some(out_rx);
        let (initialized_tx, initialized_rx) = tokio::sync::oneshot::channel();
        let initialized_tx = timeout.then_some(initialized_tx);
        let mode = Arc::new(AtomicU8::new(ConnectionMode::Active as u8));
        let started = tokio::time::Instant::now();

        let error = ws_client
            .wait_for_initialization(initialized_rx, mode)
            .await
            .unwrap_err();
        drop(initialized_tx);

        let expected = if timeout {
            "Hyperliquid WebSocket handler initialization timed out"
        } else {
            "Hyperliquid WebSocket handler stopped before initialization"
        };

        assert_eq!(error.to_string(), expected);
        assert_eq!(
            tokio::time::Instant::now() - started,
            if timeout {
                HTTP_TIMEOUT
            } else {
                Duration::ZERO
            },
        );
        assert!(!ws_client.is_active());
        assert!(ws_client.out_rx.is_none());
        assert!(ws_client.task_handle.is_empty());
        assert!(ws_client.connection_permit.lock().is_none());
        assert_eq!(
            ws_client.rate_limits.connection_slots.available_permits(),
            available,
        );
    }

    #[tokio::test]
    async fn cancelled_initialization_rejects_stale_acknowledgement() {
        let mut ws_client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        ws_client.rate_limits = Arc::new(WebSocketRateLimits::new());
        let available = ws_client.rate_limits.connection_slots.available_permits();
        *ws_client.connection_permit.lock() = Some(
            Arc::clone(&ws_client.rate_limits.connection_slots)
                .try_acquire_owned()
                .unwrap(),
        );

        let (started_tx, started_rx) = tokio::sync::oneshot::channel();
        let (stopped_tx, stopped_rx) = tokio::sync::oneshot::channel::<()>();
        ws_client
            .task_handle
            .spawn(async move {
                let _stopped_tx = stopped_tx;
                started_tx.send(()).unwrap();
                std::future::pending::<()>().await;
            })
            .unwrap();

        started_rx.await.unwrap();
        let observer = ws_client.clone();
        let old_mode = Arc::new(AtomicU8::new(ConnectionMode::Active as u8));
        let (old_tx, old_rx) = tokio::sync::oneshot::channel();
        let mut initialization =
            Box::pin(ws_client.wait_for_initialization(old_rx, Arc::clone(&old_mode)));
        let polled =
            std::future::poll_fn(|cx| std::task::Poll::Ready(initialization.as_mut().poll(cx)))
                .await;
        assert!(polled.is_pending());
        drop(initialization);
        assert!(
            tokio::time::timeout(Duration::from_secs(1), stopped_rx)
                .await
                .unwrap()
                .is_err(),
        );
        assert!(ws_client.connection_permit.lock().is_none());
        ws_client.disconnect_locked().await.unwrap();

        assert!(ws_client.task_handle.is_empty());
        assert_eq!(
            ws_client.rate_limits.connection_slots.available_permits(),
            available,
        );

        let new_mode = Arc::new(AtomicU8::new(ConnectionMode::Active as u8));
        let (new_tx, new_rx) = tokio::sync::oneshot::channel();
        let mut initialization =
            Box::pin(ws_client.wait_for_initialization(new_rx, Arc::clone(&new_mode)));
        let polled =
            std::future::poll_fn(|cx| std::task::Poll::Ready(initialization.as_mut().poll(cx)))
                .await;
        assert!(polled.is_pending());

        assert_eq!(old_tx.send(()), Err(()));
        assert!(!observer.is_active());
        new_tx.send(()).unwrap();
        initialization.await.unwrap();

        assert!(observer.is_active());
        assert!(Arc::ptr_eq(
            &observer.connection_mode.load_full(),
            &new_mode
        ));
        assert!(!Arc::ptr_eq(
            &observer.connection_mode.load_full(),
            &old_mode
        ));
    }

    #[rstest]
    fn cache_sender_reset_isolates_connection_generation() {
        let mut ws_client = HyperliquidWebSocketClient::new(
            Some("wss://test".to_string()),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let (cmd_tx, mut cmd_rx) = tokio::sync::mpsc::unbounded_channel();
        *ws_client.cache_tx.lock() = cmd_tx;
        let old = ws_client.clone();
        ws_client.reset_runtime_state();
        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());

        old.cache_instrument(instrument.clone());
        ws_client.cache_instrument(instrument.clone());

        assert!(!Arc::ptr_eq(&ws_client.cache_tx, &old.cache_tx));
        assert!(ws_client.cache_tx.lock().is_closed());
        assert!(!old.cache_tx.lock().is_closed());

        match cmd_rx.try_recv().unwrap() {
            HandlerCommand::UpdateInstrument(updated) => assert_eq!(updated, instrument),
            command => panic!("unexpected instrument command: {command:?}"),
        }

        assert!(cmd_rx.try_recv().is_err());
    }

    #[rstest]
    fn batch_cache_merges_disjoint_updates_and_preserves_commands() {
        let ws_client = HyperliquidWebSocketClient::new(
            Some("wss://test".to_string()),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
        *ws_client.cache_tx.lock() = sender;
        let mut first = crypto_perpetual_ethusdt();
        first.raw_symbol = "FIRST".into();
        first.ts_event = 17.into();
        let mut second = first.clone();
        second.id = "BTCUSDT.HYPERLIQUID".into();
        second.raw_symbol = "SECOND".into();
        second.ts_event = 29.into();
        let batches = [
            vec![InstrumentAny::CryptoPerpetual(first)],
            vec![InstrumentAny::CryptoPerpetual(second)],
        ];
        let barrier = std::sync::Barrier::new(2);
        std::thread::scope(|scope| {
            for batch in &batches {
                let client = &ws_client;
                let barrier = &barrier;
                scope.spawn(move || {
                    barrier.wait();
                    client.merge_instruments(batch);
                });
            }
        });

        assert_eq!(ws_client.instruments.len(), 2);
        let mut received = AHashMap::new();

        for _ in 0..2 {
            let HandlerCommand::UpdateInstrument(instrument) = receiver.try_recv().unwrap() else {
                panic!("expected UpdateInstrument");
            };

            received.insert(instrument.raw_symbol().inner(), instrument);
        }

        for instrument in batches.iter().flatten() {
            let key = instrument.raw_symbol().inner();
            let expected = serde_json::to_value(instrument).unwrap();
            assert_eq!(
                serde_json::to_value(ws_client.instruments.get_cloned(&key).unwrap()).unwrap(),
                expected
            );
            assert_eq!(serde_json::to_value(&received[&key]).unwrap(), expected);
        }

        assert!(receiver.try_recv().is_err());
    }

    #[tokio::test]
    async fn cache_updates_reach_handler_while_recovery_holds_sender() {
        let ws_client = HyperliquidWebSocketClient::new(
            Some("wss://test".to_string()),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let (cmd_tx, mut cmd_rx) = tokio::sync::mpsc::unbounded_channel();
        *ws_client.cmd_tx.write().await = cmd_tx.clone();
        *ws_client.cache_tx.lock() = cmd_tx;
        ws_client
            .connection_mode
            .store(Arc::new(AtomicU8::new(ConnectionMode::Active as u8)));
        let writer = ws_client.cmd_tx.write().await;
        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
        let instrument_id = instrument.id();
        let mapping =
            AHashMap::from_iter([(Ustr::from("test-dex"), vec![None, Some(instrument_id)])]);

        ws_client.cache_instrument(instrument.clone());
        ws_client.cache_all_dex_asset_ctxs_instrument_ids(mapping.clone());
        drop(writer);

        assert_eq!(
            ws_client
                .instruments
                .get_cloned(&instrument.raw_symbol().inner()),
            Some(instrument.clone())
        );
        assert_eq!(
            ws_client.all_dex_asset_ctxs_instrument_ids.load().as_ref(),
            &mapping
        );

        match cmd_rx.try_recv().unwrap() {
            HandlerCommand::UpdateInstrument(updated) => assert_eq!(updated, instrument),
            command => panic!("unexpected instrument command: {command:?}"),
        }

        match cmd_rx.try_recv().unwrap() {
            HandlerCommand::CacheAllDexAssetCtxsInstrumentIds(updated) => {
                assert_eq!(updated, mapping);
            }
            command => panic!("unexpected context command: {command:?}"),
        }

        assert!(cmd_rx.try_recv().is_err());
    }

    #[rstest]
    #[case::publication(false)]
    #[case::readiness(true)]
    #[tokio::test]
    async fn command_at_publication_or_readiness_reaches_handler(#[case] readiness: bool) {
        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
        let addr = listener.local_addr().unwrap();
        let (received_tx, mut received_rx) = tokio::sync::mpsc::unbounded_channel();

        let server = tokio::spawn(async move {
            let (socket, _) = listener.accept().await.unwrap();
            let mut socket = tokio_tungstenite::accept_async(socket).await.unwrap();
            while let Some(Ok(message)) = socket.next().await {
                if let tokio_tungstenite::tungstenite::Message::Text(text) = message {
                    let payload: serde_json::Value = serde_json::from_str(text.as_str()).unwrap();
                    let _ = received_tx.send(payload);
                }
            }
        });

        let url = format!("ws://{addr}");

        let mut ws_client = HyperliquidWebSocketClient::new(
            Some(url),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let observer = ws_client.clone();

        let command = HandlerCommand::Subscribe {
            subscriptions: vec![SubscriptionRequest::Trades {
                coin: Ustr::from("BTC"),
            }],
        };

        if readiness {
            let mut connect = Box::pin(ws_client.connect());
            let mut command = Some(command);

            let result = tokio::time::timeout(
                Duration::from_secs(5),
                std::future::poll_fn(|cx| {
                    let polled = connect.as_mut().poll(cx);

                    if observer.is_active()
                        && let Some(command) = command.take()
                    {
                        assert!(polled.is_ready(), "readiness must follow initialization");
                        observer.cmd_tx.try_read().unwrap().send(command).unwrap();
                    }

                    polled
                }),
            )
            .await
            .expect("connect must publish readiness");

            result.expect("connect failed");
            assert!(command.is_none(), "command must be sent at first readiness");
        } else {
            let publication_observer = observer.clone();
            race_command_with_publication(
                Arc::clone(&ws_client.cmd_tx),
                ws_client.connect(),
                move || {
                    assert!(!publication_observer.is_active());
                    command
                },
                || observer.is_active(),
            )
            .await
            .expect("connect failed");
        }

        let command_sender = ws_client.cmd_tx.read().await.clone();
        assert!(ws_client.cache_tx.lock().same_channel(&command_sender));
        let received = tokio::time::timeout(Duration::from_secs(2), received_rx.recv()).await;
        ws_client.disconnect().await.expect("disconnect failed");
        server.abort();

        let payload = received
            .expect("startup command must reach server")
            .unwrap();
        assert_eq!(
            payload,
            serde_json::json!({
                "method": "subscribe",
                "subscription": {
                    "type": "trades",
                    "coin": "BTC"
                }
            })
        );
    }

    #[tokio::test]
    #[ignore = "connects to Hyperliquid mainnet public market data"]
    async fn mainnet_initialization_routes_subscription() {
        let http_client =
            HyperliquidHttpClient::new(HyperliquidEnvironment::Mainnet, 15, None).unwrap();
        let instruments = http_client.request_instruments().await.unwrap();
        let instrument = instruments
            .into_iter()
            .find(|instrument| instrument.raw_symbol().as_str() == "BTC")
            .expect("BTC perpetual must exist");
        let instrument_id = instrument.id();

        let mut ws_client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Mainnet,
            None,
            TransportBackend::default(),
            None,
        );
        ws_client.cache_instrument(instrument);

        ws_client.connect().await.unwrap();
        assert!(ws_client.is_active());
        ws_client.subscribe_trades(instrument_id).await.unwrap();
        let received = tokio::time::timeout(Duration::from_secs(15), ws_client.next_event()).await;
        ws_client.disconnect().await.unwrap();

        let Some(NautilusWsMessage::Trades(trades)) = received.unwrap() else {
            panic!("expected BTC trades after immediate subscription");
        };

        assert!(!trades.is_empty());
        assert!(
            trades
                .iter()
                .all(|trade| trade.instrument_id == instrument_id)
        );
        assert!(!ws_client.is_active());
    }

    #[rstest]
    #[case("wss://stream.example.com/feed", "wss://stream.example.com")]
    #[case(
        "wss://SYN-user:SYN-password@stream.example.com:9443/SYN-path?token=SYN-query#SYN-fragment",
        "wss://stream.example.com:9443"
    )]
    fn test_debug_preserves_url_origin(#[case] url: &str, #[case] origin: &str) {
        let client = HyperliquidWebSocketClient::new(
            Some(url.to_string()),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let debug = format!("{client:?}");
        assert!(debug.contains(&format!("url: {origin:?}")));
        assert!(!debug.contains("SYN-"));
        assert_eq!(client.url.expose(), url);
    }

    #[rstest]
    fn test_debug_redacts_proxy_url() {
        let proxy_url = "http://user:password@proxy.example:8080";
        let client = HyperliquidWebSocketClient::new(
            Some("wss://test".to_string()),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            Some(proxy_url.to_string()),
        );

        let debug = format!("{client:?}");

        assert!(debug.contains(REDACTED));
        assert!(!debug.contains(proxy_url));
    }

    #[rstest]
    fn test_cache_all_dex_asset_ctxs_instrument_ids_keeps_dexes_absent_from_update() {
        let client = HyperliquidWebSocketClient::new(
            Some("wss://test".to_string()),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let btc = Some(InstrumentId::from("BTC-USD-PERP.HYPERLIQUID"));
        let eth = Some(InstrumentId::from("ETH-USD-PERP.HYPERLIQUID"));
        let tsla = Some(InstrumentId::from("xyz:TSLA-USD-PERP.HYPERLIQUID"));

        client.cache_all_dex_asset_ctxs_instrument_ids(AHashMap::from_iter([
            (Ustr::from(""), vec![btc]),
            (Ustr::from("xyz"), vec![tsla]),
        ]));
        // a `meta` fallback build covers only the default dex
        client.cache_all_dex_asset_ctxs_instrument_ids(AHashMap::from_iter([(
            Ustr::from(""),
            vec![btc, eth],
        )]));

        let cached = client.all_dex_asset_ctxs_instrument_ids.load();
        assert_eq!(cached.len(), 2);
        assert_eq!(cached.get(&Ustr::from("")), Some(&vec![btc, eth]));
        assert_eq!(cached.get(&Ustr::from("xyz")), Some(&vec![tsla]));
    }

    #[tokio::test]
    async fn test_drop_clone_does_not_stop_handler() {
        let client = HyperliquidWebSocketClient::new(
            Some("wss://test".to_string()),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        client
            .task_handle
            .insert(get_runtime().spawn(std::future::pending()));
        let clone = client.clone();

        drop(clone);

        assert!(!client.signal.load(Ordering::Acquire));
        assert!(!client.task_handle.is_empty());
    }

    /// Generates a unique topic key for a subscription request.
    fn subscription_topic(sub: &SubscriptionRequest) -> String {
        subscription_to_key(sub)
    }

    #[rstest]
    #[case(SubscriptionRequest::Trades { coin: "BTC".into() }, "trades:BTC")]
    #[case(SubscriptionRequest::Bbo { coin: "BTC".into() }, "bbo:BTC")]
    #[case(SubscriptionRequest::OrderUpdates { user: "0x123".to_string() }, "orderUpdates:0x123")]
    #[case(SubscriptionRequest::UserEvents { user: "0xabc".to_string() }, "userEvents:0xabc")]
    fn test_subscription_topic_generation(
        #[case] subscription: SubscriptionRequest,
        #[case] expected_topic: &str,
    ) {
        assert_eq!(subscription_topic(&subscription), expected_topic);
    }

    #[rstest]
    fn test_subscription_topics_unique() {
        let sub1 = SubscriptionRequest::Trades { coin: "BTC".into() };
        let sub2 = SubscriptionRequest::Bbo { coin: "BTC".into() };

        let topic1 = subscription_topic(&sub1);
        let topic2 = subscription_topic(&sub2);

        assert_ne!(topic1, topic2);
    }

    #[rstest]
    #[case(SubscriptionRequest::Trades { coin: "BTC".into() })]
    #[case(SubscriptionRequest::Bbo { coin: "ETH".into() })]
    #[case(SubscriptionRequest::Candle { coin: "SOL".into(), interval: HyperliquidBarInterval::OneHour })]
    #[case(SubscriptionRequest::OrderUpdates { user: "0x123".to_string() })]
    #[case(SubscriptionRequest::Trades { coin: "vntls:vCURSOR".into() })]
    #[case(SubscriptionRequest::L2Book { coin: "vntls:vCURSOR".into(), mantissa: None, n_sig_figs: None })]
    #[case(SubscriptionRequest::Candle { coin: "vntls:vCURSOR".into(), interval: HyperliquidBarInterval::OneHour })]
    fn test_subscription_reconstruction(#[case] subscription: SubscriptionRequest) {
        let topic = subscription_topic(&subscription);
        let reconstructed = subscription_from_topic(&topic).expect("Failed to reconstruct");
        assert_eq!(subscription_topic(&reconstructed), topic);
    }

    #[rstest]
    fn malformed_post_payload_errors_omit_private_data() {
        let ws_client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Mainnet,
            None,
            TransportBackend::default(),
            None,
        );
        let fixtures: serde_json::Value = serde_json::from_str(include_str!(
            "../../test_data/ws_malformed_private_frames.json"
        ))
        .unwrap();

        for payload in fixtures["post_valid_payloads"].as_array().unwrap() {
            let parsed = ws_client.parse_post_action_payload(payload).unwrap();
            assert_eq!(serde_json::to_value(parsed).unwrap(), *payload);
        }

        let payload = &fixtures["post_payload"];
        let e = ws_client.parse_post_action_payload(payload).unwrap_err();
        let diagnostic = e.to_string();
        let unexpected =
            HyperliquidError::decode(ws_client.post_decode_context(payload, "unexpected_info"))
                .to_string();

        assert!(matches!(e, HyperliquidError::Serde(_)));
        assert_eq!(
            diagnostic,
            format!(
                "serde error: Invalid WebSocket post response: class=action, client_id={}, payload_bytes={}, category=Data",
                ws_client.client_id,
                payload.to_string().len()
            )
        );
        assert_eq!(
            unexpected,
            format!(
                "decode error: Invalid WebSocket post response: class=action, client_id={}, payload_bytes={}, category=unexpected_info",
                ws_client.client_id,
                payload.to_string().len()
            )
        );

        for secret in fixtures["secrets"].as_array().unwrap() {
            let secret = secret.as_str().unwrap();
            assert!(!diagnostic.contains(secret));
            assert!(!unexpected.contains(secret));
        }
    }

    #[rstest]
    #[case("post_unexpected_status", "post_unexpected_status_bytes")]
    #[case("post_unexpected_status_string", "post_unexpected_status_string_bytes")]
    fn unknown_post_status_omits_private_data(#[case] payload_key: &str, #[case] bytes_key: &str) {
        let ws_client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Mainnet,
            None,
            TransportBackend::default(),
            None,
        );
        let fixtures: serde_json::Value = serde_json::from_str(include_str!(
            "../../test_data/ws_malformed_private_frames.json"
        ))
        .unwrap();
        let parsed = ws_client
            .parse_post_action_payload(&fixtures[payload_key])
            .unwrap();
        let cancel_errors = ws_client.cancel_response_errors(&parsed, 2);
        let failure = ws_client.check_post_action_response(parsed).unwrap_err();

        let PostRequestError::AfterDispatch(e) = failure else {
            panic!("unknown status must remain an ambiguous dispatched result");
        };

        let diagnostic = e.to_string();
        let debug = format!("{e:?}");
        let success = ws_client
            .parse_post_action_payload(&fixtures["post_valid_payloads"][0])
            .unwrap();
        let success = ws_client.check_post_action_response(success).unwrap();
        let rejected = ws_client
            .parse_post_action_payload(&fixtures["post_business_rejection"])
            .unwrap();
        let cancel_rejections = ws_client.cancel_response_errors(&rejected, 3);
        let rejected = ws_client.check_post_action_response(rejected).unwrap_err();

        let PostRequestError::Rejected { error, reason } = rejected else {
            panic!("known rejection must remain rejected");
        };

        assert!(matches!(&e, HyperliquidError::BadRequest(_)));
        assert_eq!(
            cancel_errors,
            vec![Some(format!("Cancel orders failed: {diagnostic}")); 2]
        );
        assert_eq!(
            cancel_rejections,
            vec![Some("Cancel orders failed: Known venue rejection".to_string()); 3]
        );
        assert_eq!(
            diagnostic,
            format!(
                "bad request: Invalid WebSocket post response: class=action, client_id={}, payload_bytes={}, category=unexpected_status",
                ws_client.client_id,
                fixtures[bytes_key].as_u64().unwrap(),
            )
        );
        assert_eq!(
            serde_json::to_value(success).unwrap(),
            fixtures["post_valid_payloads"][0]
        );
        assert!(matches!(&error, HyperliquidError::BadRequest(_)));
        assert_eq!(
            error.to_string(),
            "bad request: API error: Known venue rejection"
        );
        assert_eq!(reason, "Known venue rejection");

        for secret in fixtures["secrets"].as_array().unwrap() {
            let secret = secret.as_str().unwrap();
            assert!(!diagnostic.contains(secret));
            assert!(!debug.contains(secret));
            assert!(
                cancel_errors
                    .iter()
                    .all(|reason| !reason.as_ref().unwrap().contains(secret))
            );
        }
    }

    #[tokio::test]
    async fn malformed_submit_report_logs_omit_private_data() {
        let _capture = crate::websocket::handler::tests::capture_logs().await;

        let ws_client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Mainnet,
            None,
            TransportBackend::default(),
            None,
        );
        let signer = HyperliquidHttpClient::new(HyperliquidEnvironment::Mainnet, 10, None).unwrap();
        let fixtures: serde_json::Value = serde_json::from_str(include_str!(
            "../../test_data/ws_malformed_private_frames.json"
        ))
        .unwrap();
        let mut expected = Vec::new();

        for (payload, expected_bytes) in fixtures["post_report_payloads"]
            .as_array()
            .unwrap()
            .iter()
            .zip(fixtures["post_report_payload_bytes"].as_array().unwrap())
        {
            let response: HyperliquidExchangeResponse =
                serde_json::from_value(payload.clone()).unwrap();
            ensure_ws_action_accepted(&response, "Order submission").unwrap();
            let payload_bytes = HyperliquidWebSocketClient::response_bytes(&response);
            assert_eq!(payload_bytes as u64, expected_bytes.as_u64().unwrap());
            let single = signer.build_submit_order_report(
                InstrumentId::from("BTC-PERP.HYPERLIQUID"),
                ClientOrderId::from("PRIVATE_ORDER_SENTINEL"),
                OrderSide::Buy,
                OrderType::Limit,
                Quantity::from("1"),
                TimeInForce::Gtc,
                Some(Price::from("12345")),
                None,
                response.clone(),
            );
            let batch =
                signer.build_submit_orders_reports(&[], HyperliquidExchangeGrouping::Na, response);

            for e in [single.as_ref().unwrap_err(), batch.as_ref().unwrap_err()] {
                assert!(
                    fixtures["secrets"]
                        .as_array()
                        .unwrap()
                        .iter()
                        .any(|secret| e.to_string().contains(secret.as_str().unwrap()))
                );
                expected.push(format!(
                    "Failed to build WebSocket submit report: class=order_status, client_id={}, payload_bytes={payload_bytes}, category=conversion; awaiting WS reconciliation",
                    ws_client.client_id,
                ));
            }

            let single = ws_client.resolve_submit_report(single, payload_bytes);
            let batch = ws_client.resolve_submit_report(batch, payload_bytes);
            assert!(single.is_none());
            assert_eq!(batch.len(), 0);
        }

        let success = ws_client.resolve_submit_report(Ok(Some(42_u64)), 123);
        assert_eq!(success, Some(42));
        let messages = crate::websocket::handler::tests::captured_logs();

        let diagnostics: Vec<_> = messages
            .iter()
            .filter(|message| {
                message.starts_with("Failed to build WebSocket submit report:")
                    && message.contains(&format!("client_id={},", ws_client.client_id))
            })
            .cloned()
            .collect();

        assert_eq!(diagnostics, expected);

        for secret in fixtures["secrets"].as_array().unwrap() {
            assert!(
                messages
                    .iter()
                    .all(|message| !message.contains(secret.as_str().unwrap()))
            );
        }
    }

    #[rstest]
    fn test_subscription_topic_candle() {
        let sub = SubscriptionRequest::Candle {
            coin: "BTC".into(),
            interval: HyperliquidBarInterval::OneHour,
        };

        let topic = subscription_topic(&sub);
        assert_eq!(topic, "candle:BTC:1h");
    }

    #[rstest]
    fn with_state_sink_survives_clone() {
        let client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        )
        .with_state_sink(SocketStateSink::new(|_| {}));

        let cloned = client.clone();
        assert!(client.socket_sink.is_some());
        assert!(cloned.socket_sink.is_some());
    }

    #[rstest]
    fn clone_can_own_socket_registration() {
        let registry = SocketReconnectRegistry::default();
        let endpoint = Ustr::from("hyperliquid-data-streams");
        let client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        )
        .with_socket_control(SocketControl::with_registry(
            ClientId::from("HYPERLIQUID"),
            None,
            endpoint,
            &registry,
        ));
        let cloned = client.clone();
        let _sink = cloned.socket_control.as_ref().unwrap().sink();
        cloned
            .socket_control
            .as_ref()
            .unwrap()
            .register(|| ReconnectRequestOutcome::Accepted);

        assert!(cloned.socket_control.is_some());
        assert!(cloned.socket_sink.is_none());
        assert!(
            registry
                .handle(ClientId::from("HYPERLIQUID"), endpoint)
                .is_some()
        );

        client.socket_control.as_ref().unwrap().deregister();
        assert!(
            registry
                .handle(ClientId::from("HYPERLIQUID"), endpoint)
                .is_some()
        );

        let handle = registry
            .handle(ClientId::from("HYPERLIQUID"), endpoint)
            .unwrap();
        assert_eq!(
            handle.request_reconnect(),
            SocketReconnectRequestOutcome::Accepted
        );
        drop(cloned);
        assert!(
            registry
                .handle(ClientId::from("HYPERLIQUID"), endpoint)
                .is_none()
        );
    }

    #[rstest]
    fn set_post_timeout_updates_client_and_clone() {
        let mut client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let timeout = std::time::Duration::from_secs(7);

        client.set_post_timeout(timeout);

        assert_eq!(client.post_timeout, timeout);
        assert_eq!(client.clone().post_timeout, timeout);
    }

    #[rstest]
    #[tokio::test]
    async fn post_action_command_without_credentials_is_not_sent() {
        let client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let signer = HyperliquidHttpClient::new(HyperliquidEnvironment::Testnet, 10, None).unwrap();
        let action = HyperliquidExchangeAction::Cancel {
            cancels: Vec::new(),
            fast: None,
        };
        let result = client.post_action_command(&signer, &action).await;
        let PostRequestError::BeforeDispatch(error) = result.unwrap_err() else {
            panic!("Expected failure before dispatch");
        };
        assert_eq!(
            error.to_string(),
            "auth error: credentials required for exchange operations"
        );
    }

    #[rstest]
    #[tokio::test]
    async fn wait_for_subscriptions_confirmed_waits_for_pending_topics() {
        let client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let topic = "orderUpdates:0xabc";
        client.subscriptions.mark_subscribe(topic);

        let pending = client
            .wait_for_subscriptions_confirmed(Duration::from_millis(30))
            .await;
        client.subscriptions.confirm_subscribe(topic);
        let confirmed = client
            .wait_for_subscriptions_confirmed(Duration::from_millis(30))
            .await;

        assert_eq!(
            pending.unwrap_err().to_string(),
            r#"Subscriptions still pending after 30ms: ["orderUpdates:0xabc"]"#,
        );
        assert!(confirmed.is_ok());
    }

    #[tokio::test]
    async fn failed_connect_releases_connection_slot() {
        let mut client = HyperliquidWebSocketClient::new(
            Some("invalid-websocket-url".to_string()),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let available_before = client.rate_limits.connection_slots.available_permits();

        client
            .connect()
            .await
            .expect_err("invalid URL should fail the connection attempt");

        assert!(client.connection_permit.lock().is_none());
        assert_eq!(
            client.rate_limits.connection_slots.available_permits(),
            available_before
        );
    }

    #[rstest]
    #[case::before_dispatch(false)]
    #[case::after_dispatch(true)]
    #[tokio::test(start_paused = true)]
    async fn post_request_timeout_preserves_dispatch_evidence(#[case] dispatched: bool) {
        let client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
        *client.cmd_tx.write().await = tx;
        let timeout = if dispatched {
            Duration::from_millis(100)
        } else {
            Duration::ZERO
        };
        let started = tokio::time::Instant::now();
        let failure = client
            .send_post_request_result(
                PostRequest::Info {
                    payload: serde_json::json!({"type": "meta"}),
                },
                timeout,
            )
            .await
            .unwrap_err();

        assert_eq!(tokio::time::Instant::now() - started, timeout);

        if dispatched {
            assert!(matches!(
                failure,
                PostRequestError::AfterDispatch(HyperliquidError::Timeout)
            ));
            let HandlerCommand::Post {
                id,
                request,
                deadline,
                cancellation_token,
            } = rx.try_recv().unwrap()
            else {
                panic!("Expected post command");
            };
            assert_eq!(id, 1);
            assert_eq!(
                serde_json::to_value(request).unwrap(),
                serde_json::json!({"type": "info", "payload": {"type": "meta"}})
            );
            assert_eq!(deadline, started + timeout);
            assert!(cancellation_token.is_cancelled());
        } else {
            assert!(matches!(
                failure,
                PostRequestError::BeforeDispatch(HyperliquidError::Timeout)
            ));
        }
        assert!(matches!(
            rx.try_recv(),
            Err(tokio::sync::mpsc::error::TryRecvError::Empty)
        ));
    }

    #[rstest]
    #[tokio::test(flavor = "multi_thread")]
    async fn send_post_request_times_out_while_waiting_for_inflight_slot() {
        let client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let mut receivers = Vec::with_capacity(HYPERLIQUID_WS_POST_INFLIGHT_MAX);
        for offset in 0..HYPERLIQUID_WS_POST_INFLIGHT_MAX {
            receivers.push(
                client
                    .post_router
                    .register(10_000 + offset as u64)
                    .await
                    .unwrap(),
            );
        }

        let err = client
            .send_post_request(
                PostRequest::Info {
                    payload: serde_json::json!({"type": "clearinghouseState", "user": "0x0"}),
                },
                std::time::Duration::from_millis(25),
            )
            .await
            .expect_err("request should timeout before acquiring an inflight slot");

        assert!(matches!(err, HyperliquidError::Timeout));
        assert_eq!(receivers.len(), HYPERLIQUID_WS_POST_INFLIGHT_MAX);
    }

    #[rstest]
    #[tokio::test(flavor = "multi_thread")]
    async fn send_post_request_shares_inflight_limit_across_clients() {
        let url = Some("wss://shared-post-limit.test/ws".to_string());
        let first = HyperliquidWebSocketClient::new(
            url.clone(),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let second = HyperliquidWebSocketClient::new(
            url,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let mut receivers = Vec::with_capacity(HYPERLIQUID_WS_POST_INFLIGHT_MAX);

        for offset in 0..HYPERLIQUID_WS_POST_INFLIGHT_MAX / 2 {
            receivers.push(first.post_router.register(offset as u64).await.unwrap());
            receivers.push(
                second
                    .post_router
                    .register(10_000 + offset as u64)
                    .await
                    .unwrap(),
            );
        }

        let error = second
            .send_post_request(
                PostRequest::Info {
                    payload: serde_json::json!({"type": "meta"}),
                },
                Duration::from_millis(25),
            )
            .await
            .expect_err("shared in-flight limit should block the next post");

        assert!(matches!(error, HyperliquidError::Timeout));
        assert_eq!(receivers.len(), HYPERLIQUID_WS_POST_INFLIGHT_MAX);
    }

    #[rstest]
    fn subscription_limit_is_rejected_before_queueing_across_clients() {
        let url = Some("wss://shared-subscription-limit.test/ws".to_string());
        let first = HyperliquidWebSocketClient::new(
            url.clone(),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let second = HyperliquidWebSocketClient::new(
            url,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel();

        for index in 0..HYPERLIQUID_WS_SUBSCRIPTIONS_MAX {
            let subscription = SubscriptionRequest::Trades {
                coin: Ustr::from(&format!("COIN-{index}")),
            };
            let client = if index % 2 == 0 { &first } else { &second };
            client.send_subscription(&cmd_tx, subscription).unwrap();
        }

        let error = first
            .send_subscription(
                &cmd_tx,
                SubscriptionRequest::Trades {
                    coin: Ustr::from("OVER-LIMIT"),
                },
            )
            .expect_err("shared subscription limit should reject the next subscription");

        assert!(error.to_string().contains("at most 1000"));
        assert_eq!(cmd_rx.len(), HYPERLIQUID_WS_SUBSCRIPTIONS_MAX);
    }

    #[rstest]
    #[tokio::test]
    async fn subscribe_book_gated_at_subscription_limit_releases_book_stream() {
        let client = HyperliquidWebSocketClient::new(
            Some("wss://gated-book-limit.test/ws".to_string()),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
        let coin = instrument.raw_symbol().inner();
        client.cache_instrument(instrument.clone());
        let (cmd_tx, _cmd_rx) = tokio::sync::mpsc::unbounded_channel();
        *client.cmd_tx.write().await = cmd_tx.clone();

        for index in 0..HYPERLIQUID_WS_SUBSCRIPTIONS_MAX {
            let subscription = SubscriptionRequest::Trades {
                coin: Ustr::from(&format!("COIN-{index}")),
            };

            client.send_subscription(&cmd_tx, subscription).unwrap();
        }

        let result = client
            .subscribe_book_gated(
                instrument.id(),
                None,
                None,
                CancellationToken::new(),
                SnapshotGate::default(),
            )
            .await;

        let error = result.expect_err("subscription limit should reject the book stream");
        assert!(error.to_string().contains("at most 1000"));
        assert_eq!(client.book_streams.options(&coin), None);
    }

    #[rstest]
    fn stream_resubscribe_queues_one_atomic_command() {
        let client = HyperliquidWebSocketClient::new(
            Some("wss://atomic-resubscribe.test/ws".to_string()),
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let (cmd_tx, mut cmd_rx) = tokio::sync::mpsc::unbounded_channel();
        let subscription = SubscriptionRequest::Bbo {
            coin: Ustr::from("BTC"),
        };

        client
            .send_stream_resubscribe(&cmd_tx, subscription)
            .unwrap();

        assert!(matches!(
            cmd_rx.try_recv(),
            Ok(HandlerCommand::Resubscribe { subscription })
                if subscription_to_key(&subscription) == "bbo:BTC"
        ));
        assert!(matches!(
            cmd_rx.try_recv(),
            Err(tokio::sync::mpsc::error::TryRecvError::Empty)
        ));
    }

    #[rstest]
    #[tokio::test(start_paused = true)]
    async fn send_post_request_uses_deadline_while_waiting_for_command_channel() {
        let client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let _cmd_tx = client.cmd_tx.write().await;
        let timeout = Duration::from_millis(100);
        let started = tokio::time::Instant::now();

        let error = client
            .send_post_request(
                PostRequest::Info {
                    payload: serde_json::json!({"type": "clearinghouseState", "user": "0x0"}),
                },
                timeout,
            )
            .await
            .unwrap_err();

        assert!(matches!(error, HyperliquidError::Timeout));
        assert_eq!(tokio::time::Instant::now() - started, timeout);
        client
            .post_router
            .register(1)
            .await
            .expect("post ID should be reusable when timeout returns");
    }

    #[rstest]
    #[tokio::test(start_paused = true)]
    async fn post_response_ready_before_deadline_wins_deadline_race() {
        let client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let id = 1;
        let cancellation_token = CancellationToken::new();
        let rx = client
            .post_router
            .register_with_cancellation(id, &cancellation_token)
            .await
            .unwrap();
        let payload = serde_json::json!({"type": "meta", "data": {"universe": []}});
        client
            .post_router
            .complete(PostResponse {
                id,
                response: PostResponsePayload::Info {
                    payload: payload.clone(),
                },
            })
            .await;

        let response = client
            .await_post_response(id, rx, tokio::time::Instant::now(), &cancellation_token)
            .await
            .expect("ready response should win");

        assert_eq!(response.id, id);
        let PostResponsePayload::Info {
            payload: response_payload,
        } = response.response
        else {
            panic!("expected info response");
        };
        assert_eq!(response_payload, payload);
    }

    #[rstest]
    #[tokio::test]
    async fn dropping_post_request_cancels_work_and_releases_registration() {
        let client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let (cmd_tx, mut cmd_rx) = tokio::sync::mpsc::unbounded_channel();
        *client.cmd_tx.write().await = cmd_tx;
        let request_client = client.clone();
        let task = tokio::spawn(async move {
            request_client
                .send_post_request(
                    PostRequest::Info {
                        payload: serde_json::json!({"type": "userRateLimit", "user": "0x123"}),
                    },
                    Duration::from_secs(60),
                )
                .await
        });
        let command = cmd_rx.recv().await.expect("post command should be queued");
        let HandlerCommand::Post {
            id,
            cancellation_token,
            ..
        } = command
        else {
            panic!("expected post command");
        };

        task.abort();
        assert!(task.await.unwrap_err().is_cancelled());
        assert!(cancellation_token.is_cancelled());

        let reused = tokio::time::timeout(Duration::from_secs(1), async {
            loop {
                match client.post_router.register(id).await {
                    Ok(rx) => break Ok(rx),
                    Err(e) if e.to_string().contains("already registered") => {
                        tokio::task::yield_now().await;
                    }
                    Err(e) => break Err(e),
                }
            }
        })
        .await
        .expect("post ID should be reusable after cancellation")
        .expect("post ID reuse should succeed");
        client
            .post_router
            .cancel_registration(id, &cancellation_token)
            .await;
        client
            .post_router
            .register(id)
            .await
            .expect_err("stale cancellation must not remove the reused registration");

        let mut receivers = vec![reused];
        tokio::time::timeout(Duration::from_secs(1), async {
            for offset in 1..HYPERLIQUID_WS_POST_INFLIGHT_MAX {
                receivers.push(
                    client
                        .post_router
                        .register(10_000 + offset as u64)
                        .await
                        .unwrap(),
                );
            }
        })
        .await
        .expect("cancellation should release the inflight permit");

        assert_eq!(receivers.len(), HYPERLIQUID_WS_POST_INFLIGHT_MAX);
    }

    #[rstest]
    #[tokio::test(start_paused = true)]
    async fn post_timeout_after_queueing_preserves_unknown_outcome_and_releases_registration() {
        let client = HyperliquidWebSocketClient::new(
            None,
            HyperliquidEnvironment::Testnet,
            None,
            TransportBackend::default(),
            None,
        );
        let (cmd_tx, mut cmd_rx) = tokio::sync::mpsc::unbounded_channel();
        *client.cmd_tx.write().await = cmd_tx;
        let request_client = client.clone();
        let task = tokio::spawn(async move {
            request_client
                .send_post_request(
                    PostRequest::Info {
                        payload: serde_json::json!({"type": "userRateLimit", "user": "0x123"}),
                    },
                    Duration::from_millis(100),
                )
                .await
        });
        let command = cmd_rx.recv().await.expect("post command should be queued");
        let HandlerCommand::Post {
            id,
            cancellation_token,
            ..
        } = command
        else {
            panic!("expected post command");
        };

        let error = task.await.unwrap().unwrap_err();

        assert!(matches!(&error, HyperliquidError::Timeout));
        assert!(error.is_transport_error());
        assert!(cancellation_token.is_cancelled());
        client
            .post_router
            .register(id)
            .await
            .expect("post ID should be reusable when timeout returns");
    }

    #[rstest]
    fn cancel_errors_for_requests_accepts_empty_as_success() {
        let errors = cancel_errors_for_requests(Vec::new(), 2).unwrap();

        assert_eq!(errors, vec![None, None]);
    }

    #[rstest]
    fn cancel_errors_for_requests_rejects_status_count_mismatch() {
        let err = cancel_errors_for_requests(vec![None], 2).expect_err("mismatch should fail");

        assert!(
            err.to_string()
                .contains("returned 1 statuses for 2 cancels")
        );
    }

    #[rstest]
    fn test_post_payload_error_maps_rate_limit() {
        let err = map_post_payload_error("429 Too Many Requests".to_string(), 3);

        assert!(matches!(
            err,
            HyperliquidError::RateLimit {
                scope: "exchange",
                weight: 3,
                retry_after_ms: None,
            }
        ));
    }

    #[rstest]
    #[case("401 Unauthorized")]
    #[case("HTTP 403: forbidden")]
    #[case("invalid signature")]
    #[case("authentication failed")]
    fn test_post_payload_error_maps_auth(#[case] payload: &str) {
        let err = map_post_payload_error(payload.to_string(), 1);

        assert!(matches!(err, HyperliquidError::Auth(_)));
    }

    #[rstest]
    #[case("400 Bad Request")]
    #[case("HTTP 400: malformed payload")]
    #[case("bad request: missing action")]
    fn test_post_payload_error_maps_bad_request(#[case] payload: &str) {
        let err = map_post_payload_error(payload.to_string(), 1);

        assert!(matches!(err, HyperliquidError::BadRequest(_)));
    }

    #[rstest]
    #[case("500 Internal Server Error")]
    #[case("HTTP 503: service unavailable")]
    fn test_post_payload_error_maps_exchange_status(#[case] payload: &str) {
        let err = map_post_payload_error(payload.to_string(), 1);

        assert!(matches!(err, HyperliquidError::Exchange(_)));
    }

    #[rstest]
    #[case("order 429001 rejected")]
    #[case("asset 5001 is not tradable")]
    #[case("authoritative nonce window exceeded")]
    fn test_post_payload_error_does_not_match_embedded_codes_or_words(#[case] payload: &str) {
        let err = map_post_payload_error(payload.to_string(), 1);

        assert!(matches!(err, HyperliquidError::Exchange(_)));
    }
}