Skip to main content

nautilus_hyperliquid/
execution.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Live execution client implementation for the Hyperliquid adapter.
17
18use std::{
19    sync::Arc,
20    time::{Duration, Instant},
21};
22
23use ahash::AHashMap;
24use anyhow::Context;
25use async_trait::async_trait;
26use nautilus_common::{
27    cache::fifo::FifoCache,
28    clients::{ExecutionClient, ExecutionReportTask},
29    live::runner::get_exec_event_sender,
30    messages::execution::{
31        BatchCancelOrders, CancelAllOrders, CancelOrder, GenerateFillReports,
32        GenerateOrderStatusReport, GenerateOrderStatusReports, GeneratePositionStatusReports,
33        ModifyOrder, QueryAccount, QueryOrder, SubmitOrder, SubmitOrderList,
34    },
35};
36use nautilus_core::{
37    DurationNanos, Params, UUID4, UnixNanos,
38    time::{AtomicTime, get_atomic_clock_realtime},
39};
40use nautilus_live::{
41    ExecutionClientCore, ExecutionEventEmitter, SocketControl,
42    execution::{
43        context::OrderContext, failure::CommandFailure, reports::retain_order_status_reports,
44    },
45    task::{TaskGroup, TaskGroupGuard, TaskSpawner},
46};
47use nautilus_model::{
48    accounts::AccountAny,
49    enums::{AccountType, OmsType, OrderSide, OrderStatus, OrderType},
50    events::{OrderDeniedReason, OrderEventAny},
51    identifiers::{
52        AccountId, ClientId, ClientOrderId, InstrumentId, StrategyId, Venue, VenueOrderId,
53    },
54    instruments::{Instrument, InstrumentAny},
55    orders::{Order, any::OrderAny},
56    reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
57    types::{AccountBalance, MarginBalance, Quantity},
58};
59use parking_lot::Mutex;
60use rust_decimal::Decimal;
61use ustr::Ustr;
62
63use crate::{
64    account::resolve_execution_account_address,
65    common::{
66        consts::{
67            HYPERLIQUID_BUILDER_APPROVAL_DOCS_URL, HYPERLIQUID_BUILDER_FEE_NOT_APPROVED,
68            HYPERLIQUID_POST_ONLY_WOULD_MATCH, HYPERLIQUID_VENUE,
69        },
70        credential::Secrets,
71        enums::{HyperliquidAccountAbstraction, HyperliquidProductType},
72        parse::{
73            clamp_price_to_precision, derive_limit_from_trigger, derive_market_order_price,
74            extract_error_message, extract_inner_error, extract_inner_errors,
75            normalize_or_validate_wire_price, order_to_hyperliquid_request_with_optional_decimals,
76            parse_combined_account_balances_and_margins, round_to_sig_figs,
77        },
78    },
79    config::HyperliquidExecutionClientConfig,
80    http::{
81        client::{HYPERLIQUID_RECENT_HISTORY_LIMIT, HyperliquidHttpClient},
82        models::{
83            ClearinghouseState, Cloid, HyperliquidExchangeAction,
84            HyperliquidExchangeCancelByCloidRequest, HyperliquidExchangeCancelOrderRequest,
85            HyperliquidExchangeGrouping, HyperliquidExchangeModifyOrderRequest,
86            HyperliquidExchangeModifyTarget, HyperliquidExchangeOrderKind,
87            HyperliquidExchangePlaceOrderRequest, HyperliquidExchangeTpSl, HyperliquidFills,
88            HyperliquidOrderStatusEntry, SpotClearinghouseState,
89        },
90        parse::derive_outcome_settlements,
91    },
92    outcome_settlement::{OutcomeSettlementTracker, build_settlement_fills},
93    websocket::{
94        ExecutionReport, NautilusWsMessage, USER_STREAMS_ENDPOINT,
95        client::{HyperliquidWebSocketClient, PostRequestError},
96        dispatch::{
97            CorrectiveReduce, DispatchOutcome, WsDispatchState, dispatch_order_event,
98            dispatch_order_fill, promote_replacement_from_query, venue_oid,
99        },
100    },
101};
102
103const TASK_SHUTDOWN_DENIAL_REASON: &str = "Hyperliquid execution client is shutting down";
104const RECONNECT_SUBSCRIPTION_TIMEOUT: Duration = Duration::from_secs(10);
105
106// Covers timestamp disorder between `orderUpdates` and `userEvents` and clock skew in the
107// stream start time; recovered reports the stream already processed are deduplicated.
108const RECONNECT_RECOVERY_MARGIN: DurationNanos = DurationNanos::from_secs(30);
109
110// The history endpoints can lag the live state by seconds, so recovery reads them again after this
111const RECONNECT_FOLLOW_UP_DELAY: Duration = Duration::from_secs(5);
112
113#[derive(Debug)]
114pub struct HyperliquidExecutionClient {
115    core: ExecutionClientCore,
116    clock: &'static AtomicTime,
117    config: HyperliquidExecutionClientConfig,
118    emitter: ExecutionEventEmitter,
119    http_client: HyperliquidHttpClient,
120    ws_client: HyperliquidWebSocketClient,
121    instruments_pending: Vec<InstrumentAny>,
122    session_tasks: TaskGroup,
123    pending_tasks: TaskGroup,
124    shutdown_errors: Vec<String>,
125    ws_dispatch_state: Arc<WsDispatchState>,
126    staged_brackets: Arc<Mutex<StagedBracketState>>,
127    outcome_settlement_tracker: Arc<Mutex<OutcomeSettlementTracker>>,
128}
129
130impl HyperliquidExecutionClient {
131    /// Arms, replaces, or clears the account-wide scheduled cancellation of all open orders.
132    ///
133    /// See [`HyperliquidHttpClient::schedule_cancel`] for timestamp and lifecycle requirements.
134    ///
135    /// # Errors
136    ///
137    /// Returns an error if [`HyperliquidHttpClient::schedule_cancel`] fails.
138    pub async fn schedule_cancel(&self, time: Option<u64>) -> anyhow::Result<()> {
139        self.http_client.schedule_cancel(time).await?;
140        Ok(())
141    }
142
143    /// Returns a reference to the configuration.
144    pub fn config(&self) -> &HyperliquidExecutionClientConfig {
145        &self.config
146    }
147
148    /// Returns a reference to the shared WebSocket dispatch state.
149    ///
150    /// Exposes the context map, pending-modify markers, and cached venue
151    /// order ids used by the two-tier dispatch contract. The state is
152    /// read-write via an [`Arc`]; callers must not mutate it directly, but
153    /// it is useful for inspection in tests and for live debugging.
154    #[must_use]
155    pub fn ws_dispatch_state(&self) -> &Arc<WsDispatchState> {
156        &self.ws_dispatch_state
157    }
158
159    /// Returns `true` when every background task spawned via `spawn_task`
160    /// has completed.
161    ///
162    /// Used in tests to wait for submit / modify / cancel action round-trips
163    /// that fire on the runtime to finish before asserting on dispatch
164    /// state, avoiding bare `sleep` calls when a negative condition needs
165    /// to be checked after the spawned work is done.
166    #[must_use]
167    pub fn pending_tasks_all_finished(&self) -> bool {
168        self.pending_tasks.all_finished()
169    }
170
171    fn resolve_slippage_bps(&self, params: Option<&Params>) -> u32 {
172        params
173            .and_then(|p| p.get_u64("market_order_slippage_bps"))
174            .map_or(self.config.market_order_slippage_bps, |v| v as u32)
175    }
176
177    fn validate_order_submission(&self, order: &OrderAny) -> anyhow::Result<()> {
178        validate_order_for_hyperliquid(order)?;
179        anyhow::ensure!(
180            self.http_client.allows_instrument(order.instrument_id()),
181            "Order outside execution product scope"
182        );
183        Ok(())
184    }
185
186    fn order_request(
187        &self,
188        order: &OrderAny,
189        slippage_bps: u32,
190    ) -> anyhow::Result<HyperliquidExchangePlaceOrderRequest> {
191        self.validate_order_submission(order)?;
192
193        let symbol = order.instrument_id().symbol.inner();
194        let asset = self
195            .http_client
196            .get_asset_index_for_symbol(symbol)
197            .with_context(|| format!("Asset index not found for {symbol}"))?;
198        let price_decimals = self.http_client.get_price_precision_for_symbol(symbol);
199        let cloid = self
200            .http_client
201            .cached_client_order_id_cloid(&order.client_order_id())
202            .unwrap_or_else(|| Cloid::from_client_order_id(order.client_order_id()));
203        let mut request = order_to_hyperliquid_request_with_optional_decimals(
204            order,
205            asset,
206            price_decimals,
207            self.config.normalize_prices,
208            slippage_bps,
209            None,
210        )?;
211        request.cloid = Some(cloid);
212
213        if let Some(base_size) = self
214            .quote_converted_size(order)
215            .map_err(|reason| anyhow::anyhow!("{reason}"))?
216        {
217            request.size = base_size;
218        }
219
220        // Market orders need a limit price derived from the cached quote,
221        // leaving the conversion's zero placeholder when none is cached.
222        if order.order_type() == OrderType::Market {
223            let instrument_id = order.instrument_id();
224            let cache = self.core.cache();
225
226            if let Some(quote) = cache.quote(&instrument_id) {
227                let is_buy = order.order_side() == OrderSide::Buy;
228                request.price = derive_market_order_price(
229                    quote,
230                    is_buy,
231                    price_decimals.unwrap_or(2),
232                    slippage_bps,
233                );
234            }
235        }
236
237        Ok(request)
238    }
239
240    // Hyperliquid accepts only base-denominated sizes on the wire, so a quote
241    // amount must convert (or deny) before it can reach the venue.
242    fn quote_converted_size(&self, order: &OrderAny) -> Result<Option<Decimal>, OrderDeniedReason> {
243        if !order.is_quote_quantity() {
244            return Ok(None);
245        }
246
247        let instrument_id = order.instrument_id();
248        let cache = self.core.cache();
249
250        let Some(instrument) = cache.instrument(&instrument_id) else {
251            return Err(OrderDeniedReason::InstrumentNotFound { instrument_id });
252        };
253
254        let Some(quote) = cache.quote(&instrument_id) else {
255            return Err(OrderDeniedReason::MarketPriceUnavailable {
256                order_type: order.order_type(),
257                instrument_id,
258            });
259        };
260
261        let reference_price = if order.order_side() == OrderSide::Buy {
262            quote.ask_price
263        } else {
264            quote.bid_price
265        };
266
267        let base_size = instrument
268            .try_calculate_base_quantity(order.quantity(), reference_price)
269            .map_err(|e| OrderDeniedReason::ValidationFailed {
270                detail: format!("Quote-denominated quantity conversion failed: {e}"),
271            })?;
272
273        if base_size.is_zero() {
274            return Err(OrderDeniedReason::ValidationFailed {
275                detail: format!(
276                    "Quote-denominated quantity {} converts to a zero base size at the instrument size precision",
277                    order.quantity()
278                ),
279            });
280        }
281
282        Ok(Some(base_size.as_decimal().normalize()))
283    }
284
285    fn restore_staged_brackets(&self) -> Vec<ClientOrderId> {
286        let order_lists = self
287            .core
288            .cache()
289            .order_lists(Some(&self.core.venue), None, None, None)
290            .into_iter()
291            .cloned()
292            .collect::<Vec<_>>();
293        let mut ready_parent_ids = Vec::new();
294
295        for order_list in order_lists {
296            let orders = {
297                let cache = self.core.cache();
298                order_list
299                    .client_order_ids
300                    .iter()
301                    .filter_map(|client_order_id| {
302                        cache.order(client_order_id).map(|order| order.clone())
303                    })
304                    .collect::<Vec<_>>()
305            };
306
307            if orders.len() != order_list.client_order_ids.len()
308                || determine_order_list_grouping(&orders) != HyperliquidExchangeGrouping::NormalTpsl
309            {
310                continue;
311            }
312
313            let (mut orders, mut requests) = match orders
314                .iter()
315                .map(|order| self.order_request(order, self.config.market_order_slippage_bps))
316                .collect::<anyhow::Result<Vec<_>>>()
317            {
318                Ok(requests) => order_normal_tpsl_submission(
319                    orders,
320                    requests,
321                    HyperliquidExchangeGrouping::NormalTpsl,
322                ),
323                Err(e) => {
324                    log::warn!("Cannot restore staged bracket {}: {e}", order_list.id,);
325                    continue;
326                }
327            };
328            let parent = orders.remove(0);
329            let parent_request = requests.remove(0);
330            let parent_id = parent.client_order_id();
331            let (staged_children, active_children): (Vec<_>, Vec<_>) = orders
332                .drain(..)
333                .zip(requests.drain(..))
334                .filter(|(order, _)| order.is_active_local())
335                .map(|(order, request)| StagedBracketChild { order, request })
336                .partition(|child| child.order.status() == OrderStatus::Initialized);
337
338            if (staged_children.is_empty() && active_children.is_empty())
339                || (!parent.is_open() && parent.filled_qty().is_zero())
340                || self.staged_brackets.lock().contains_parent(&parent_id)
341            {
342                continue;
343            }
344
345            self.restore_order_context(&parent, &parent_request);
346            for child in &active_children {
347                self.restore_order_context(&child.order, &child.request);
348            }
349
350            let has_staged_children = !staged_children.is_empty();
351            let mut state = self.staged_brackets.lock();
352            if has_staged_children {
353                state.stage(parent_id, staged_children);
354            }
355            state.restore_active(&active_children);
356            drop(state);
357
358            if has_staged_children && parent.filled_qty().non_zero() {
359                ready_parent_ids.push(parent_id);
360            }
361        }
362
363        if !ready_parent_ids.is_empty() {
364            log::info!(
365                "Restored {} staged bracket parent(s) with prior fills",
366                ready_parent_ids.len(),
367            );
368        }
369
370        ready_parent_ids
371    }
372
373    fn restore_order_context(
374        &self,
375        order: &OrderAny,
376        request: &HyperliquidExchangePlaceOrderRequest,
377    ) {
378        let client_order_id = order.client_order_id();
379        let cloid = request.cloid.expect("order conversion must set a CLOID");
380        self.http_client
381            .cache_client_order_id_cloid(client_order_id, cloid);
382        self.ws_client
383            .cache_cloid_mapping(Ustr::from(&cloid.to_hex()), client_order_id);
384        self.ws_dispatch_state
385            .register_context(OrderContext::from(order));
386
387        if let Some(venue_order_id) = order.venue_order_id() {
388            self.ws_dispatch_state
389                .record_venue_order_id(client_order_id, venue_order_id);
390            self.ws_dispatch_state.insert_accepted(client_order_id);
391        }
392    }
393
394    /// Creates a new [`HyperliquidExecutionClient`].
395    ///
396    /// # Errors
397    ///
398    /// Returns an error if the configuration is invalid or either transport fails to construct.
399    pub fn new(
400        core: ExecutionClientCore,
401        config: HyperliquidExecutionClientConfig,
402    ) -> anyhow::Result<Self> {
403        config.validate()?;
404
405        let secrets = Secrets::resolve(
406            config
407                .private_key
408                .as_ref()
409                .map(|value| value.expose_secret()),
410            config.vault_address.as_deref(),
411            config.environment,
412        )
413        .context("Hyperliquid execution client requires private key")?;
414
415        let account_address = resolve_execution_account_address(
416            config
417                .private_key
418                .as_ref()
419                .map(|value| value.expose_secret()),
420            config.vault_address.as_deref(),
421            config.account_address.as_deref(),
422            config.environment,
423        )?;
424        let proxy_url = config
425            .proxy_url
426            .as_ref()
427            .map(|value| value.expose_secret().to_owned());
428
429        let mut http_client = HyperliquidHttpClient::with_secrets(
430            &secrets,
431            config.http_timeout_secs,
432            proxy_url.clone(),
433        )
434        .context("failed to create Hyperliquid HTTP client")?;
435
436        http_client.set_product_types(config.product_types.clone())?;
437        http_client.set_account_id(core.account_id);
438        http_client.set_account_address(account_address)?;
439        http_client.set_normalize_prices(config.normalize_prices);
440        http_client.set_market_order_slippage_bps(config.market_order_slippage_bps);
441        http_client.set_include_builder_attribution(config.include_builder_attribution);
442        http_client.set_info_retry_config(
443            config.max_retries,
444            Duration::from_millis(config.retry_delay_initial_ms),
445            Duration::from_millis(config.retry_delay_max_ms),
446        );
447
448        if let Some(url) = &config.base_url_http {
449            http_client.set_base_info_url(url.clone());
450        }
451
452        if let Some(url) = &config.base_url_exchange {
453            http_client.set_base_exchange_url(url.clone());
454        }
455
456        let ws_url = config.base_url_ws.clone();
457        let mut ws_client = HyperliquidWebSocketClient::new(
458            ws_url,
459            config.environment,
460            Some(core.account_id),
461            config.transport_backend,
462            proxy_url,
463        );
464        ws_client = ws_client.with_socket_control(SocketControl::new(
465            core.client_id,
466            Some(*HYPERLIQUID_VENUE),
467            USER_STREAMS_ENDPOINT,
468        ));
469        ws_client.set_post_timeout(Duration::from_secs(config.ws_post_timeout_secs));
470
471        let clock = get_atomic_clock_realtime();
472        let emitter = ExecutionEventEmitter::new(
473            clock,
474            core.trader_id,
475            core.account_id,
476            AccountType::Margin,
477            None,
478        );
479
480        let session_tasks = TaskGroup::new();
481        let pending_tasks = TaskGroup::new();
482
483        Ok(Self {
484            core,
485            clock,
486            config,
487            emitter,
488            http_client,
489            ws_client,
490            instruments_pending: Vec::new(),
491            session_tasks,
492            pending_tasks,
493            shutdown_errors: Vec::new(),
494            ws_dispatch_state: Arc::new(WsDispatchState::new()),
495            staged_brackets: Arc::new(Mutex::new(StagedBracketState::default())),
496            outcome_settlement_tracker: Arc::new(Mutex::new(OutcomeSettlementTracker::new())),
497        })
498    }
499
500    async fn ensure_instruments_initialized_async(&mut self) -> anyhow::Result<()> {
501        if self.core.instruments_initialized() {
502            return Ok(());
503        }
504
505        let instruments = self
506            .http_client
507            .request_instruments()
508            .await
509            .context("failed to request Hyperliquid instruments")?;
510
511        if instruments.is_empty() {
512            log::warn!(
513                "Instrument bootstrap yielded no instruments; WebSocket submissions may fail"
514            );
515        } else {
516            log::debug!("Initialized {} instruments", instruments.len());
517        }
518
519        // Preserve arrival order for spot aliases, then let fetched definitions replace updates
520        let mut pending = std::mem::take(&mut self.instruments_pending);
521        pending.extend(instruments);
522        self.http_client.merge_instruments(&pending);
523        self.ws_client.merge_instruments(&pending);
524
525        self.core.set_instruments_initialized();
526        Ok(())
527    }
528
529    async fn refresh_account_state(
530        &self,
531    ) -> anyhow::Result<(
532        ClearinghouseState,
533        SpotClearinghouseState,
534        HyperliquidAccountAbstraction,
535    )> {
536        let account_address = self.get_account_address()?;
537
538        let (perp_state, spot_state, abstraction) = self
539            .fetch_combined_clearinghouse_state(&account_address)
540            .await?;
541
542        log::debug!(
543            "Received clearinghouse state: cross_margin_summary={:?}, asset_positions={}, spot_balances={}",
544            perp_state.cross_margin_summary,
545            perp_state.asset_positions.len(),
546            spot_state.balances.len(),
547        );
548
549        // Emit for unfunded wallets too, which carry only zero balances, so the account
550        // registers for await_account_registered.
551        emit_account_state(
552            &self.emitter,
553            &perp_state,
554            &spot_state,
555            abstraction,
556            self.clock.get_time_ns(),
557        )?;
558
559        log::debug!("Account state updated successfully");
560        Ok((perp_state, spot_state, abstraction))
561    }
562
563    async fn fetch_combined_clearinghouse_state(
564        &self,
565        account_address: &str,
566    ) -> anyhow::Result<(
567        ClearinghouseState,
568        SpotClearinghouseState,
569        HyperliquidAccountAbstraction,
570    )> {
571        let perp_json = self
572            .http_client
573            .info_clearinghouse_state(account_address)
574            .await
575            .context("failed to fetch clearinghouse state")?;
576        let perp_state: ClearinghouseState = serde_json::from_value(perp_json)
577            .context("failed to deserialize clearinghouse state")?;
578
579        let spot_json = self
580            .http_client
581            .info_spot_clearinghouse_state(account_address)
582            .await
583            .context("failed to fetch spot clearinghouse state")?;
584        let spot_state: SpotClearinghouseState = serde_json::from_value(spot_json)
585            .context("failed to deserialize spot clearinghouse state")?;
586
587        let abstraction = self
588            .http_client
589            .info_user_abstraction(account_address)
590            .await
591            .context("failed to fetch user abstraction")?;
592
593        Ok((perp_state, spot_state, abstraction))
594    }
595
596    async fn await_account_registered(&self, timeout_secs: f64) -> anyhow::Result<()> {
597        let account_id = self.core.account_id;
598
599        if self.core.cache().account(&account_id).is_some() {
600            log::info!("Account {account_id} registered");
601            return Ok(());
602        }
603
604        let start = Instant::now();
605        let timeout = Duration::from_secs_f64(timeout_secs);
606        let interval = Duration::from_millis(10);
607
608        loop {
609            tokio::time::sleep(interval).await;
610
611            if self.core.cache().account(&account_id).is_some() {
612                log::info!("Account {account_id} registered");
613                return Ok(());
614            }
615
616            if start.elapsed() >= timeout {
617                anyhow::bail!(
618                    "Timeout waiting for account {account_id} to be registered after {timeout_secs}s"
619                );
620            }
621        }
622    }
623
624    fn report_client(&self) -> anyhow::Result<HyperliquidReportClient> {
625        // Reports can be collected before connect() initializes the transport caches
626        self.http_client
627            .merge_instruments(&self.instruments_pending);
628        Ok(HyperliquidReportClient {
629            http_client: self.http_client.clone(),
630            account_address: self.get_account_address()?,
631        })
632    }
633
634    fn cached_report_oid(&self, cmd: &GenerateOrderStatusReport) -> Option<u64> {
635        if cmd.venue_order_id.is_some() {
636            return None;
637        }
638
639        cmd.client_order_id.and_then(|client_order_id| {
640            self.core
641                .cache()
642                .venue_order_id(&client_order_id)
643                .and_then(|value| value.as_str().parse().ok())
644        })
645    }
646
647    fn get_account_address(&self) -> anyhow::Result<String> {
648        self.http_client
649            .get_account_address()
650            .context("failed to get account address from HTTP client")
651    }
652
653    fn spawn_task<F>(&self, description: &'static str, fut: F) -> bool
654    where
655        F: std::future::Future<Output = anyhow::Result<()>> + Send + 'static,
656    {
657        let future = async move {
658            if let Err(e) = fut.await {
659                log::warn!("{description} failed: {e:?}");
660            }
661        };
662
663        match self.pending_tasks.spawn(future) {
664            Ok(()) => true,
665            Err(e) => {
666                log::warn!("Skipping Hyperliquid {description} after shutdown began: {e}");
667                false
668            }
669        }
670    }
671
672    async fn start_scheduled_cancel(&self) -> anyhow::Result<()> {
673        let Some(timeout_secs) = self.config.scheduled_cancel_timeout_secs else {
674            return Ok(());
675        };
676
677        let timeout = Duration::from_secs(timeout_secs);
678        let refresh_interval = timeout / 3;
679        refresh_scheduled_cancel(&self.http_client, self.clock, timeout, refresh_interval)
680            .await
681            .context("failed to arm Hyperliquid scheduled cancellation")?;
682
683        let http_client = self.http_client.clone();
684        let ws_client = self.ws_client.clone();
685        let clock = self.clock;
686        let cancellation = self.session_tasks.cancellation_token();
687
688        self.session_tasks.spawn(async move {
689            let mut interval = tokio::time::interval_at(
690                tokio::time::Instant::now() + refresh_interval,
691                refresh_interval,
692            );
693            interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
694
695            loop {
696                tokio::select! {
697                    biased;
698                    () = cancellation.cancelled() => break,
699                    _ = interval.tick() => {}
700                }
701
702                if !ws_client.is_active() {
703                    continue;
704                }
705
706                tokio::select! {
707                    biased;
708                    () = cancellation.cancelled() => break,
709                    result = refresh_scheduled_cancel(&http_client, clock, timeout, refresh_interval) => {
710                        if let Err(e) = result {
711                            log::error!("Scheduled cancellation refresh failed; the last deadline may expire: {e:#}");
712                        }
713                    }
714                }
715            }
716        })?;
717
718        log::info!("Scheduled cancellation armed: timeout_secs={timeout_secs}");
719        Ok(())
720    }
721
722    fn start_outcome_settlement_poll(&self) -> anyhow::Result<()> {
723        if !self
724            .config
725            .product_types
726            .contains(&HyperliquidProductType::Outcome)
727        {
728            return Ok(());
729        }
730
731        let poll_secs = self.config.outcome_settlement_poll_secs;
732        if poll_secs == 0 {
733            log::debug!("Outcome settlement polling disabled by config");
734            return Ok(());
735        }
736
737        let http_client = self.http_client.clone();
738        let emitter = self.emitter.clone();
739        let tracker = self.outcome_settlement_tracker.clone();
740        let account_id = self.core.account_id;
741        let account_address = self.get_account_address()?;
742        let clock = self.clock;
743
744        self.session_tasks.spawn(async move {
745            let mut interval = tokio::time::interval(Duration::from_secs(poll_secs));
746            interval.tick().await;
747
748            loop {
749                interval.tick().await;
750
751                let meta = match http_client.get_outcome_meta().await {
752                    Ok(meta) => meta,
753                    Err(e) => {
754                        log::warn!("Outcome meta poll failed: {e}");
755                        continue;
756                    }
757                };
758
759                let settlements = derive_outcome_settlements(&meta);
760                if settlements.is_empty() {
761                    continue;
762                }
763
764                let spot_json = match http_client
765                    .info_spot_clearinghouse_state(&account_address)
766                    .await
767                {
768                    Ok(value) => value,
769                    Err(e) => {
770                        log::warn!("Settlement dispatch skipped: spot state fetch failed: {e}");
771                        continue;
772                    }
773                };
774                let spot_state: SpotClearinghouseState = match serde_json::from_value(spot_json) {
775                    Ok(state) => state,
776                    Err(e) => {
777                        log::warn!("Settlement dispatch skipped: spot state parse failed: {e}");
778                        continue;
779                    }
780                };
781
782                let ts = clock.get_time_ns();
783                let fills = {
784                    let mut guard = tracker.lock();
785                    build_settlement_fills(
786                        &settlements,
787                        &spot_state,
788                        &meta,
789                        &http_client,
790                        &mut guard,
791                        account_id,
792                        ts,
793                    )
794                };
795
796                for fill in fills {
797                    log::debug!(
798                        "Dispatching outcome settlement fill: instrument={}, price={}, qty={}",
799                        fill.instrument_id,
800                        fill.last_px,
801                        fill.last_qty,
802                    );
803                    emitter.send_fill_report(fill);
804                }
805            }
806        })?;
807
808        Ok(())
809    }
810
811    fn abort_pending_tasks(&self) {
812        self.pending_tasks.abort();
813    }
814
815    fn begin_session_shutdown(&self) {
816        self.session_tasks.begin_shutdown();
817        self.ws_client.begin_shutdown();
818    }
819
820    async fn teardown_partial_connect(&mut self) -> anyhow::Result<()> {
821        self.begin_session_shutdown();
822        self.pending_tasks.begin_shutdown();
823
824        if let Err(e) = self.ws_client.disconnect().await {
825            self.shutdown_errors
826                .push(format!("Hyperliquid WebSocket shutdown failed: {e}"));
827        }
828
829        if let Err(e) = self.await_session_tasks().await {
830            self.shutdown_errors.push(e.to_string());
831        }
832
833        if let Err(e) = self.await_pending_tasks().await {
834            self.shutdown_errors.push(e.to_string());
835        }
836        self.core.set_disconnected();
837
838        if !self.shutdown_errors.is_empty() {
839            anyhow::bail!(std::mem::take(&mut self.shutdown_errors).join("; "));
840        }
841        Ok(())
842    }
843
844    async fn await_pending_tasks(&self) -> anyhow::Result<()> {
845        self.pending_tasks.begin_shutdown();
846        self.pending_tasks
847            .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
848            .await
849            .map_err(|e| anyhow::anyhow!("Failed to terminate Hyperliquid execution tasks: {e}"))?;
850        Ok(())
851    }
852
853    async fn await_session_tasks(&self) -> anyhow::Result<()> {
854        self.session_tasks.begin_shutdown();
855        self.session_tasks
856            .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
857            .await
858            .map_err(|e| {
859                anyhow::anyhow!("Failed to terminate Hyperliquid execution session tasks: {e}")
860            })?;
861        Ok(())
862    }
863}
864
865#[async_trait(?Send)]
866impl ExecutionClient for HyperliquidExecutionClient {
867    fn provides_bulk_position_coverage(&self, instrument_id: InstrumentId) -> bool {
868        self.http_client.allows_instrument(instrument_id)
869    }
870
871    fn is_connected(&self) -> bool {
872        self.core.is_connected()
873    }
874
875    fn client_id(&self) -> ClientId {
876        self.core.client_id
877    }
878
879    fn account_id(&self) -> AccountId {
880        self.core.account_id
881    }
882
883    fn venue(&self) -> Venue {
884        *HYPERLIQUID_VENUE
885    }
886
887    fn oms_type(&self) -> OmsType {
888        self.core.oms_type
889    }
890
891    fn get_account(&self) -> Option<AccountAny> {
892        self.core.cache().account_owned(&self.core.account_id)
893    }
894
895    fn generate_account_state(
896        &self,
897        balances: Vec<AccountBalance>,
898        margins: Vec<MarginBalance>,
899        reported: bool,
900        ts_event: UnixNanos,
901        info: Option<Params>,
902    ) -> anyhow::Result<()> {
903        self.emitter
904            .emit_account_state(balances, margins, reported, ts_event, info);
905        Ok(())
906    }
907
908    /// Registers an instrument published by the data client so a market listed
909    /// after this client bootstrapped becomes submittable without a restart.
910    ///
911    /// Before bootstrap, updates are buffered for batch caching.
912    ///
913    /// The HTTP client takes the venue asset index from the instrument's `info`
914    /// map. WebSocket submissions sign through `&self.http_client`, so that one
915    /// write serves both submission paths.
916    fn on_instrument(&mut self, instrument: InstrumentAny) {
917        if !self.core.instruments_initialized() {
918            // Batch the startup drain to avoid cloning growing caches for every instrument
919            self.instruments_pending.push(instrument);
920            return;
921        }
922
923        // this is the only step that makes a market listed after our bootstrap
924        // submittable, so it is traceable rather than silent
925        log::debug!(
926            "Applying instrument update: instrument_id={}",
927            instrument.id()
928        );
929        self.http_client.cache_instrument(&instrument);
930        self.ws_client.cache_instrument(instrument);
931    }
932
933    fn start(&mut self) -> anyhow::Result<()> {
934        if self.core.is_started() {
935            return Ok(());
936        }
937
938        let sender = get_exec_event_sender();
939        self.emitter.set_sender(sender);
940        self.core.set_started();
941
942        log::info!(
943            "Started: client_id={}, account_id={}, environment={:?}, vault_address={:?}, proxy_url={:?}",
944            self.core.client_id,
945            self.core.account_id,
946            self.config.environment,
947            self.config.vault_address,
948            self.config.proxy_url,
949        );
950
951        Ok(())
952    }
953
954    fn stop(&mut self) -> anyhow::Result<()> {
955        if self.core.is_stopped() {
956            return Ok(());
957        }
958
959        log::info!("Stopping Hyperliquid execution client");
960
961        self.session_tasks.abort();
962        self.abort_pending_tasks();
963        self.ws_client.begin_shutdown();
964
965        self.core.set_stopped();
966        self.core.set_disconnected();
967
968        log::info!("Hyperliquid execution client stopped");
969        Ok(())
970    }
971
972    fn submit_order(&self, cmd: SubmitOrder) -> anyhow::Result<()> {
973        let order = self.core.cache().try_order_owned(&cmd.client_order_id)?;
974
975        if order.is_closed() {
976            log::warn!("Cannot submit closed order {}", order.client_order_id());
977            return Ok(());
978        }
979
980        if let Err(e) = self.validate_order_submission(&order) {
981            self.emitter.emit_order_denied(
982                &order,
983                &OrderDeniedReason::ValidationFailed {
984                    detail: e.to_string(),
985                }
986                .to_string(),
987            );
988            return Ok(());
989        }
990
991        let http_client = self.http_client.clone();
992        let symbol = order.instrument_id().symbol.inner();
993
994        // Complete venue conversion before emitting OrderSubmitted
995        let asset = match http_client.get_asset_index_for_symbol(symbol) {
996            Some(a) => a,
997            None => {
998                self.emitter.emit_order_denied(
999                    &order,
1000                    &OrderDeniedReason::InstrumentNotFound {
1001                        instrument_id: order.instrument_id(),
1002                    }
1003                    .to_string(),
1004                );
1005                return Ok(());
1006            }
1007        };
1008
1009        let price_decimals = http_client.get_price_precision_for_symbol(symbol);
1010        let slippage_bps = self.resolve_slippage_bps(cmd.params.as_ref());
1011        let mut hyperliquid_order = match order_to_hyperliquid_request_with_optional_decimals(
1012            &order,
1013            asset,
1014            price_decimals,
1015            self.config.normalize_prices,
1016            slippage_bps,
1017            None,
1018        ) {
1019            Ok(req) => req,
1020            Err(e) => {
1021                self.emitter.emit_order_denied(
1022                    &order,
1023                    &OrderDeniedReason::ValidationFailed {
1024                        detail: format!("Order conversion failed: {e}"),
1025                    }
1026                    .to_string(),
1027                );
1028                return Ok(());
1029            }
1030        };
1031        let task_spawner = match self.pending_tasks.spawner() {
1032            Ok(spawner) => spawner,
1033            Err(e) => {
1034                log::warn!("Skipping Hyperliquid submit_order after shutdown began: {e}");
1035                self.emitter.emit_order_denied(
1036                    &order,
1037                    &OrderDeniedReason::SubmitFailed {
1038                        detail: TASK_SHUTDOWN_DENIAL_REASON.to_string(),
1039                    }
1040                    .to_string(),
1041                );
1042                return Ok(());
1043            }
1044        };
1045        let cloid = http_client
1046            .cached_client_order_id_cloid(&order.client_order_id())
1047            .unwrap_or_else(|| Cloid::from_client_order_id(order.client_order_id()));
1048        hyperliquid_order.cloid = Some(cloid);
1049
1050        match self.quote_converted_size(&order) {
1051            Ok(Some(base_size)) => hyperliquid_order.size = base_size,
1052            Ok(None) => {}
1053            Err(reason) => {
1054                self.emitter.emit_order_denied(&order, &reason.to_string());
1055                return Ok(());
1056            }
1057        }
1058
1059        if order.order_type() == OrderType::Market {
1060            let instrument_id = order.instrument_id();
1061            let cache = self.core.cache();
1062            match cache.quote(&instrument_id) {
1063                Some(quote) => {
1064                    let is_buy = order.order_side() == OrderSide::Buy;
1065                    hyperliquid_order.price = derive_market_order_price(
1066                        quote,
1067                        is_buy,
1068                        price_decimals.unwrap_or(2),
1069                        slippage_bps,
1070                    );
1071                }
1072                None => {
1073                    self.emitter.emit_order_denied(
1074                        &order,
1075                        &OrderDeniedReason::MarketPriceUnavailable {
1076                            order_type: order.order_type(),
1077                            instrument_id,
1078                        }
1079                        .to_string(),
1080                    );
1081                    return Ok(());
1082                }
1083            }
1084        }
1085
1086        log::debug!(
1087            "Submitting order: id={}, type={:?}, side={:?}, price={}, size={}, kind={:?}",
1088            order.client_order_id(),
1089            order.order_type(),
1090            order.order_side(),
1091            hyperliquid_order.price,
1092            hyperliquid_order.size,
1093            hyperliquid_order.kind,
1094        );
1095
1096        let emitter = self.emitter.clone();
1097        let clock = self.clock;
1098        let ws_client = self.ws_client.clone();
1099        let cloid_hex = Ustr::from(&cloid.to_hex());
1100        let dispatch_state = self.ws_dispatch_state.clone();
1101        let nested_spawner = task_spawner.clone();
1102        let builder = self.http_client.builder_attribution();
1103        let denied_order = order.clone();
1104
1105        if let Err(e) = task_spawner.spawn(async move {
1106            http_client.cache_client_order_id_cloid(order.client_order_id(), cloid);
1107            ws_client.cache_cloid_mapping(cloid_hex, order.client_order_id());
1108            register_order_context_into(&dispatch_state, &order);
1109            emitter.emit_order_submitted(&order);
1110
1111            let action = HyperliquidExchangeAction::Order {
1112                orders: vec![hyperliquid_order],
1113                grouping: HyperliquidExchangeGrouping::Na,
1114                builder,
1115            };
1116            let rejection_route = PostRejectionRoute::new(
1117                &emitter,
1118                &ws_client,
1119                &http_client,
1120                dispatch_state.clone(),
1121                nested_spawner,
1122            );
1123
1124            match ws_client
1125                .post_action_command(&http_client, &action)
1126                .await
1127                .map_err(classify_post_failure)
1128            {
1129                Ok(response) => {
1130                    if let Some(reason) = extract_inner_error(&response) {
1131                        rejection_route.emit_once(&order, &reason, clock.get_time_ns(), &cloid_hex);
1132                    }
1133                }
1134                Err(CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason)) => {
1135                    rejection_route.emit_once(&order, &reason, clock.get_time_ns(), &cloid_hex);
1136                }
1137                Err(CommandFailure::Ambiguous(reason)) => {
1138                    log::warn!(
1139                        "Submit outcome unknown for {}: {reason}; awaiting reconciliation",
1140                        order.client_order_id()
1141                    );
1142                }
1143            }
1144            rejection_route.resolve_without_post_rejection(&order, clock.get_time_ns(), &cloid_hex);
1145        }) {
1146            log::warn!("Skipping Hyperliquid submit_order after shutdown began: {e}");
1147            self.emitter.emit_order_denied(
1148                &denied_order,
1149                &OrderDeniedReason::SubmitFailed {
1150                    detail: TASK_SHUTDOWN_DENIAL_REASON.to_string(),
1151                }
1152                .to_string(),
1153            );
1154        }
1155
1156        Ok(())
1157    }
1158
1159    fn submit_order_list(&self, cmd: SubmitOrderList) -> anyhow::Result<()> {
1160        log::debug!(
1161            "Submitting order list with {} orders",
1162            cmd.order_list.client_order_ids.len()
1163        );
1164
1165        let http_client = self.http_client.clone();
1166        let slippage_bps = self.resolve_slippage_bps(cmd.params.as_ref());
1167
1168        let orders = self.core.get_orders_for_list(&cmd.order_list)?;
1169
1170        let mut valid_orders = Vec::new();
1171        let mut hyperliquid_orders = Vec::new();
1172
1173        for order in &orders {
1174            match self.order_request(order, slippage_bps) {
1175                Ok(request) => {
1176                    // Deny MARKET orders without a cached quote, matching
1177                    // the single-order path.
1178                    if order.order_type() == OrderType::Market {
1179                        let instrument_id = order.instrument_id();
1180                        if self.core.cache().quote(&instrument_id).is_none() {
1181                            self.emitter.emit_order_denied(
1182                                order,
1183                                &OrderDeniedReason::MarketPriceUnavailable {
1184                                    order_type: order.order_type(),
1185                                    instrument_id,
1186                                }
1187                                .to_string(),
1188                            );
1189                            continue;
1190                        }
1191                    }
1192
1193                    hyperliquid_orders.push(request);
1194                    valid_orders.push(order.clone());
1195                }
1196                Err(e) => {
1197                    self.emitter.emit_order_denied(
1198                        order,
1199                        &OrderDeniedReason::ValidationFailed {
1200                            detail: format!("Order conversion failed: {e}"),
1201                        }
1202                        .to_string(),
1203                    );
1204                }
1205            }
1206        }
1207
1208        // A bracket whose entry failed conversion must not submit its
1209        // children: they would rest at the venue as orphan exits.
1210        if determine_order_list_grouping(&orders) == HyperliquidExchangeGrouping::NormalTpsl
1211            && valid_orders
1212                .first()
1213                .is_none_or(|o| o.client_order_id() != orders[0].client_order_id())
1214        {
1215            for order in &valid_orders {
1216                self.emitter.emit_order_denied(
1217                    order,
1218                    &OrderDeniedReason::OrderListDenied {
1219                        order_list_id: cmd.order_list.id,
1220                    }
1221                    .to_string(),
1222                );
1223            }
1224            return Ok(());
1225        }
1226
1227        if valid_orders.is_empty() {
1228            log::warn!("No valid orders to submit in order list");
1229            return Ok(());
1230        }
1231
1232        let task_spawner = match self.pending_tasks.spawner() {
1233            Ok(spawner) => spawner,
1234            Err(e) => {
1235                log::warn!("Skipping Hyperliquid submit_order_list after shutdown began: {e}");
1236
1237                for order in &valid_orders {
1238                    self.emitter.emit_order_denied(
1239                        order,
1240                        &OrderDeniedReason::SubmitFailed {
1241                            detail: TASK_SHUTDOWN_DENIAL_REASON.to_string(),
1242                        }
1243                        .to_string(),
1244                    );
1245                }
1246                return Ok(());
1247            }
1248        };
1249        let denied_orders = valid_orders.clone();
1250
1251        let grouping = determine_order_list_grouping(&valid_orders);
1252        log::debug!("Order list grouping: {grouping:?}");
1253        let (mut valid_orders, mut hyperliquid_orders) =
1254            order_normal_tpsl_submission(valid_orders, hyperliquid_orders, grouping);
1255
1256        let (submission_grouping, staged_children) =
1257            if grouping == HyperliquidExchangeGrouping::NormalTpsl {
1258                let parent = valid_orders.remove(0);
1259                let parent_request = hyperliquid_orders.remove(0);
1260                let children = valid_orders
1261                    .drain(..)
1262                    .zip(hyperliquid_orders.drain(..))
1263                    .map(|(order, request)| StagedBracketChild { order, request })
1264                    .collect();
1265                let staged_children = Some((parent.client_order_id(), children));
1266                valid_orders.push(parent);
1267                hyperliquid_orders.push(parent_request);
1268                (HyperliquidExchangeGrouping::Na, staged_children)
1269            } else {
1270                (grouping, None)
1271            };
1272
1273        let emitter = self.emitter.clone();
1274        let clock = self.clock;
1275        let ws_client = self.ws_client.clone();
1276        let dispatch_state = self.ws_dispatch_state.clone();
1277        let staged_brackets = self.staged_brackets.clone();
1278        let builder = self.http_client.builder_attribution();
1279        let nested_spawner = task_spawner.clone();
1280
1281        if let Err(e) = task_spawner.spawn(async move {
1282            if let Some((parent_id, children)) = staged_children {
1283                staged_brackets.lock().stage(parent_id, children);
1284            }
1285
1286            for (order, request) in valid_orders.iter().zip(hyperliquid_orders.iter()) {
1287                let cloid = request.cloid.expect("order conversion must set a CLOID");
1288                http_client.cache_client_order_id_cloid(order.client_order_id(), cloid);
1289                ws_client.cache_cloid_mapping(Ustr::from(&cloid.to_hex()), order.client_order_id());
1290                register_order_context_into(&dispatch_state, order);
1291                emitter.emit_order_submitted(order);
1292            }
1293
1294            post_order_batch(
1295                "Order list",
1296                valid_orders,
1297                hyperliquid_orders,
1298                submission_grouping,
1299                builder,
1300                &emitter,
1301                &ws_client,
1302                &http_client,
1303                dispatch_state,
1304                staged_brackets,
1305                clock,
1306                nested_spawner,
1307            )
1308            .await;
1309        }) {
1310            log::warn!("Skipping Hyperliquid submit_order_list after shutdown began: {e}");
1311
1312            for order in &denied_orders {
1313                self.emitter.emit_order_denied(
1314                    order,
1315                    &OrderDeniedReason::SubmitFailed {
1316                        detail: TASK_SHUTDOWN_DENIAL_REASON.to_string(),
1317                    }
1318                    .to_string(),
1319                );
1320            }
1321        }
1322
1323        Ok(())
1324    }
1325
1326    fn modify_order(&self, cmd: ModifyOrder) -> anyhow::Result<()> {
1327        log::debug!("Modifying order: {cmd}");
1328
1329        let client_order_id = cmd.client_order_id;
1330        let venue_order_id = cmd
1331            .venue_order_id
1332            .or_else(|| self.core.cache().venue_order_id(&client_order_id).copied());
1333
1334        let order = match self.core.cache().order(&client_order_id).map(|o| o.clone()) {
1335            Some(o) => o,
1336            None => {
1337                let reason = "order not found in cache";
1338                log::warn!("Cannot modify order {client_order_id}: {reason}");
1339                self.emitter.emit_order_modify_denied_event(
1340                    cmd.strategy_id,
1341                    cmd.instrument_id,
1342                    client_order_id,
1343                    venue_order_id,
1344                    reason,
1345                    self.clock.get_time_ns(),
1346                    Some(cmd.command_id),
1347                );
1348                return Ok(());
1349            }
1350        };
1351
1352        if !self.http_client.allows_instrument(cmd.instrument_id)
1353            || !self.http_client.allows_instrument(order.instrument_id())
1354        {
1355            emit_modify_failure(
1356                &self.emitter,
1357                &cmd,
1358                venue_order_id,
1359                CommandFailure::not_sent("Order outside execution product scope"),
1360                self.clock.get_time_ns(),
1361            );
1362            return Ok(());
1363        }
1364
1365        let http_client = self.http_client.clone();
1366        let symbol = cmd.instrument_id.symbol.inner();
1367        let should_normalize = self.config.normalize_prices;
1368        let slippage_bps = self.resolve_slippage_bps(cmd.params.as_ref());
1369
1370        // A modify replaces a base-denominated size, and a quote target cannot
1371        // be reconciled against the venue's base-denominated fill reports.
1372        if order.is_quote_quantity() {
1373            let reason =
1374                "quote-denominated quantity orders cannot be modified; cancel and resubmit";
1375            log::warn!("Cannot modify order {client_order_id}: {reason}");
1376            self.emitter.emit_order_modify_denied_event(
1377                cmd.strategy_id,
1378                cmd.instrument_id,
1379                client_order_id,
1380                venue_order_id,
1381                reason,
1382                self.clock.get_time_ns(),
1383                Some(cmd.command_id),
1384            );
1385            return Ok(());
1386        }
1387
1388        let modify_target = match http_client.unique_cached_client_order_id_cloid(&client_order_id)
1389        {
1390            Some(cloid) => HyperliquidExchangeModifyTarget::Cloid(cloid),
1391            None => {
1392                let Some(venue_order_id) = venue_order_id.as_ref() else {
1393                    let reason = "venue_order_id or unique cached CLOID is required for modify";
1394                    log::warn!("Cannot modify order {client_order_id}: {reason}");
1395                    self.emitter.emit_order_modify_denied_event(
1396                        cmd.strategy_id,
1397                        cmd.instrument_id,
1398                        client_order_id,
1399                        None,
1400                        reason,
1401                        self.clock.get_time_ns(),
1402                        Some(cmd.command_id),
1403                    );
1404                    return Ok(());
1405                };
1406
1407                match HyperliquidExchangeModifyTarget::from_venue_order_id(venue_order_id) {
1408                    Ok(target) => target,
1409                    Err(e) => {
1410                        let reason =
1411                            format!("Failed to parse venue_order_id '{venue_order_id}': {e}");
1412                        log::warn!("{reason}");
1413                        self.emitter.emit_order_modify_denied_event(
1414                            cmd.strategy_id,
1415                            cmd.instrument_id,
1416                            client_order_id,
1417                            Some(*venue_order_id),
1418                            &reason,
1419                            self.clock.get_time_ns(),
1420                            Some(cmd.command_id),
1421                        );
1422                        return Ok(());
1423                    }
1424                }
1425            }
1426        };
1427        let old_venue_order_id = venue_order_id.filter(|id| id.as_str().parse::<u64>().is_ok());
1428        if matches!(modify_target, HyperliquidExchangeModifyTarget::Cloid(_))
1429            && old_venue_order_id.is_none()
1430        {
1431            let reason = "cached venue_order_id is required for CLOID modify";
1432            log::warn!("Cannot modify order {client_order_id}: {reason}");
1433            self.emitter.emit_order_modify_denied_event(
1434                cmd.strategy_id,
1435                cmd.instrument_id,
1436                client_order_id,
1437                venue_order_id,
1438                reason,
1439                self.clock.get_time_ns(),
1440                Some(cmd.command_id),
1441            );
1442            return Ok(());
1443        }
1444
1445        // Hyperliquid modify is cancel-replace; subtract filled to avoid overfill.
1446        let target_total_qty = cmd.quantity.unwrap_or(order.quantity());
1447        let filled_qty = order.filled_qty();
1448        if target_total_qty <= filled_qty {
1449            let reason =
1450                format!("modify quantity {target_total_qty} not greater than filled {filled_qty}",);
1451            log::warn!("Cannot modify order {}: {reason}", cmd.client_order_id);
1452
1453            self.emitter.emit_order_modify_denied_event(
1454                cmd.strategy_id,
1455                cmd.instrument_id,
1456                client_order_id,
1457                venue_order_id,
1458                &reason,
1459                self.clock.get_time_ns(),
1460                Some(cmd.command_id),
1461            );
1462            return Ok(());
1463        }
1464
1465        let quantity = target_total_qty - filled_qty;
1466        let price_decimals = http_client.get_price_precision_for_symbol(symbol);
1467        let asset = match http_client.get_asset_index_for_symbol(symbol) {
1468            Some(a) => a,
1469            None => {
1470                emit_modify_failure(
1471                    &self.emitter,
1472                    &cmd,
1473                    venue_order_id,
1474                    CommandFailure::not_sent(format!("Asset index not found for symbol {symbol}")),
1475                    self.clock.get_time_ns(),
1476                );
1477                return Ok(());
1478            }
1479        };
1480
1481        // Build base request from cached order (derives slippage-adjusted
1482        // limit for trigger-market types like StopMarket/MarketIfTouched)
1483        let mut hyperliquid_order = match order_to_hyperliquid_request_with_optional_decimals(
1484            &order,
1485            asset,
1486            price_decimals,
1487            should_normalize,
1488            slippage_bps,
1489            None,
1490        ) {
1491            Ok(mut req) => {
1492                let applied = (|| -> anyhow::Result<()> {
1493                    if let Some(p) = cmd.price.or(order.price()) {
1494                        req.price = normalize_or_validate_wire_price(
1495                            p.as_decimal(),
1496                            "Price",
1497                            price_decimals,
1498                            should_normalize,
1499                        )?;
1500                    } else if let Some(tp) = cmd.trigger_price {
1501                        // Trigger changed but no explicit price: re-derive the
1502                        // slippage-adjusted limit from the new trigger
1503                        let is_buy = order.order_side() == OrderSide::Buy;
1504                        let base = tp.as_decimal().normalize();
1505                        let derived = derive_limit_from_trigger(base, is_buy, slippage_bps);
1506                        let sig_rounded = round_to_sig_figs(derived, 5);
1507                        req.price = clamp_price_to_precision(
1508                            sig_rounded,
1509                            price_decimals.unwrap_or(2),
1510                            is_buy,
1511                        )
1512                        .normalize();
1513                    }
1514                    req.size = quantity.as_decimal().normalize();
1515
1516                    if let (Some(tp), HyperliquidExchangeOrderKind::Trigger { trigger }) =
1517                        (cmd.trigger_price, &mut req.kind)
1518                    {
1519                        trigger.trigger_px = normalize_or_validate_wire_price(
1520                            tp.as_decimal(),
1521                            "Trigger price",
1522                            price_decimals,
1523                            should_normalize,
1524                        )?;
1525                    }
1526                    Ok(())
1527                })();
1528
1529                match applied {
1530                    Ok(()) => req,
1531                    Err(e) => {
1532                        emit_modify_failure(
1533                            &self.emitter,
1534                            &cmd,
1535                            venue_order_id,
1536                            CommandFailure::not_sent(format!(
1537                                "Order conversion failed for modify: {e}"
1538                            )),
1539                            self.clock.get_time_ns(),
1540                        );
1541                        return Ok(());
1542                    }
1543                }
1544            }
1545            Err(e) => {
1546                emit_modify_failure(
1547                    &self.emitter,
1548                    &cmd,
1549                    venue_order_id,
1550                    CommandFailure::not_sent(format!("Order conversion failed for modify: {e}")),
1551                    self.clock.get_time_ns(),
1552                );
1553                return Ok(());
1554            }
1555        };
1556        let cached_cloid_before_modify = http_client.cached_client_order_id_cloid(&client_order_id);
1557        let cloid = http_client.get_or_generate_client_order_id_cloid(order.client_order_id());
1558        let generated_modify_cloid = cached_cloid_before_modify
1559            .is_none()
1560            .then_some((client_order_id, cloid));
1561        hyperliquid_order.cloid = Some(cloid);
1562
1563        let dispatch_state = self.ws_dispatch_state.clone();
1564        let ws_client = self.ws_client.clone();
1565
1566        if let Some(cloid) = hyperliquid_order.cloid {
1567            http_client.cache_client_order_id_cloid(client_order_id, cloid);
1568            ws_client.cache_cloid_mapping(Ustr::from(&cloid.to_hex()), client_order_id);
1569        }
1570
1571        // Register on the command thread so concurrent tasks cannot stash a request
1572        // onto another modify intent. Failed admission clears only this generation.
1573        let modify_generation = old_venue_order_id.map(|old_venue_order_id| {
1574            let generation = dispatch_state.mark_pending_modify(
1575                client_order_id,
1576                old_venue_order_id,
1577                target_total_qty,
1578            );
1579            // The promotion uses this request to reduce a replacement after an in-flight fill
1580            dispatch_state.stash_modify_request(client_order_id, hyperliquid_order.clone());
1581            generation
1582        });
1583
1584        let emitter = self.emitter.clone();
1585        let clock = self.clock;
1586        let command = cmd.clone();
1587
1588        if !self.spawn_task("modify_order", async move {
1589            let action = HyperliquidExchangeAction::Modify {
1590                modify: HyperliquidExchangeModifyOrderRequest {
1591                    oid: modify_target,
1592                    order: hyperliquid_order,
1593                },
1594            };
1595
1596            let failure = match ws_client
1597                .post_action_command(&http_client, &action)
1598                .await
1599                .map_err(classify_post_failure)
1600            {
1601                Ok(response) => extract_inner_error(&response).map(CommandFailure::venue_rejected),
1602                Err(failure) => Some(failure),
1603            };
1604
1605            if let Some(failure) = failure {
1606                if !matches!(failure, CommandFailure::Ambiguous(_)) {
1607                    if let Some(generation) = modify_generation {
1608                        dispatch_state.clear_modify_generation(&client_order_id, generation);
1609                    }
1610                    remove_generated_modify_cloid(&http_client, &ws_client, generated_modify_cloid);
1611                }
1612                emit_modify_failure(
1613                    &emitter,
1614                    &command,
1615                    venue_order_id,
1616                    failure,
1617                    clock.get_time_ns(),
1618                );
1619            }
1620            Ok(())
1621        }) {
1622            if let Some(generation) = modify_generation {
1623                self.ws_dispatch_state
1624                    .clear_modify_generation(&client_order_id, generation);
1625            }
1626            remove_generated_modify_cloid(
1627                &self.http_client,
1628                &self.ws_client,
1629                generated_modify_cloid,
1630            );
1631            emit_modify_failure(
1632                &self.emitter,
1633                &cmd,
1634                venue_order_id,
1635                CommandFailure::not_sent(TASK_SHUTDOWN_DENIAL_REASON),
1636                self.clock.get_time_ns(),
1637            );
1638        }
1639
1640        Ok(())
1641    }
1642
1643    fn cancel_order(&self, cmd: CancelOrder) -> anyhow::Result<()> {
1644        log::debug!("Cancelling order: {cmd}");
1645
1646        let emitter = self.emitter.clone();
1647        let clock = self.clock;
1648        let client_order_id = cmd.client_order_id;
1649        let strategy_id = cmd.strategy_id;
1650        let instrument_id = cmd.instrument_id;
1651        let venue_order_id = cmd.venue_order_id;
1652        let symbol = cmd.instrument_id.symbol.inner();
1653        let fast = can_fast_cancel_order(
1654            self.core
1655                .cache()
1656                .order(&client_order_id)
1657                .as_ref()
1658                .map(|order| order.order_type()),
1659        )
1660        .then_some(true);
1661        let entry = CancelEntry {
1662            command_id: cmd.command_id,
1663            strategy_id,
1664            instrument_id,
1665            client_order_id,
1666            venue_order_id,
1667            symbol,
1668            fast: fast.is_some(),
1669        };
1670
1671        if !self.http_client.allows_instrument(instrument_id) {
1672            emit_cancel_failure(
1673                &emitter,
1674                &entry,
1675                CommandFailure::not_sent("Order outside execution product scope"),
1676                clock.get_time_ns(),
1677            );
1678            return Ok(());
1679        }
1680
1681        if let Some(order) = self
1682            .staged_brackets
1683            .lock()
1684            .cancel_child(&cmd.client_order_id)
1685        {
1686            self.emitter
1687                .emit_order_canceled(&order, None, self.clock.get_time_ns());
1688            return Ok(());
1689        }
1690
1691        let http_client = self.http_client.clone();
1692        let ws_client = self.ws_client.clone();
1693        let rejected_entry = entry.clone();
1694
1695        if !self.spawn_task("cancel_order", async move {
1696            let asset = match http_client.get_asset_index_for_symbol(symbol) {
1697                Some(a) => a,
1698                None => {
1699                    emit_cancel_failure(
1700                        &emitter,
1701                        &entry,
1702                        CommandFailure::not_sent(format!(
1703                            "Asset index not found for symbol {symbol}"
1704                        )),
1705                        clock.get_time_ns(),
1706                    );
1707                    return Ok(());
1708                }
1709            };
1710
1711            let action =
1712                if let Some(cloid) = http_client.cached_client_order_id_cloid(&client_order_id) {
1713                    HyperliquidExchangeAction::CancelByCloid {
1714                        cancels: vec![HyperliquidExchangeCancelByCloidRequest { asset, cloid }],
1715                        fast,
1716                    }
1717                } else if let Some(venue_order_id) = venue_order_id {
1718                    match venue_order_id.as_str().parse::<u64>() {
1719                        Ok(oid) => HyperliquidExchangeAction::Cancel {
1720                            cancels: vec![HyperliquidExchangeCancelOrderRequest { asset, oid }],
1721                            fast,
1722                        },
1723                        Err(_) => {
1724                            emit_cancel_failure(
1725                                &emitter,
1726                                &entry,
1727                                CommandFailure::not_sent("Invalid venue order ID format"),
1728                                clock.get_time_ns(),
1729                            );
1730                            return Ok(());
1731                        }
1732                    }
1733                } else {
1734                    let cloid = http_client.get_or_generate_client_order_id_cloid(client_order_id);
1735                    HyperliquidExchangeAction::CancelByCloid {
1736                        cancels: vec![HyperliquidExchangeCancelByCloidRequest { asset, cloid }],
1737                        fast,
1738                    }
1739                };
1740
1741            let failure = match ws_client
1742                .post_action_command(&http_client, &action)
1743                .await
1744                .map_err(classify_post_failure)
1745            {
1746                Ok(response) => extract_inner_error(&response).map(CommandFailure::venue_rejected),
1747                Err(failure) => Some(failure),
1748            };
1749
1750            if let Some(failure) = failure {
1751                emit_cancel_failure(&emitter, &entry, failure, clock.get_time_ns());
1752            }
1753            Ok(())
1754        }) {
1755            emit_cancel_failure(
1756                &self.emitter,
1757                &rejected_entry,
1758                CommandFailure::not_sent(TASK_SHUTDOWN_DENIAL_REASON),
1759                self.clock.get_time_ns(),
1760            );
1761        }
1762
1763        Ok(())
1764    }
1765
1766    fn cancel_all_orders(&self, cmd: CancelAllOrders) -> anyhow::Result<()> {
1767        log::debug!("Cancelling all orders: {cmd}");
1768
1769        let cache = self.core.cache();
1770        let open_orders = cache.orders_open(
1771            Some(&self.core.venue),
1772            Some(&cmd.instrument_id),
1773            None,
1774            None,
1775            cmd.order_side,
1776        );
1777
1778        if open_orders.is_empty() {
1779            log::debug!("No open orders to cancel for {:?}", cmd.instrument_id);
1780            return Ok(());
1781        }
1782
1783        let symbol = cmd.instrument_id.symbol.inner();
1784        let instrument_id = cmd.instrument_id;
1785        let strategy_id = cmd.strategy_id;
1786        let entries: Vec<CancelEntry> = open_orders
1787            .iter()
1788            .map(|o| CancelEntry {
1789                command_id: cmd.command_id,
1790                strategy_id,
1791                instrument_id,
1792                client_order_id: o.client_order_id(),
1793                venue_order_id: o.venue_order_id(),
1794                symbol,
1795                fast: can_fast_cancel_order(Some(o.order_type())),
1796            })
1797            .collect();
1798
1799        let emitter = self.emitter.clone();
1800        let clock = self.clock;
1801
1802        if !self.http_client.allows_instrument(instrument_id) {
1803            for entry in &entries {
1804                emit_cancel_failure(
1805                    &emitter,
1806                    entry,
1807                    CommandFailure::not_sent("Order outside execution product scope"),
1808                    clock.get_time_ns(),
1809                );
1810            }
1811            return Ok(());
1812        }
1813
1814        let http_client = self.http_client.clone();
1815        let ws_client = self.ws_client.clone();
1816        let rejected_entries = entries.clone();
1817
1818        if !self.spawn_task("cancel_all_orders", async move {
1819            let asset = match http_client.get_asset_index_for_symbol(symbol) {
1820                Some(a) => a,
1821                None => {
1822                    for entry in &entries {
1823                        emit_cancel_failure(
1824                            &emitter,
1825                            entry,
1826                            CommandFailure::not_sent(format!(
1827                                "Asset index not found for symbol {symbol}"
1828                            )),
1829                            clock.get_time_ns(),
1830                        );
1831                    }
1832                    return Ok(());
1833                }
1834            };
1835
1836            let mut cancel_dispatch = CancelDispatch::new();
1837
1838            for entry in &entries {
1839                if let Err(failure) = cancel_dispatch.push(entry, asset, &http_client) {
1840                    emit_cancel_failure(&emitter, entry, failure, clock.get_time_ns());
1841                }
1842            }
1843
1844            if cancel_dispatch.is_empty() {
1845                return Ok(());
1846            }
1847
1848            submit_cancel_dispatch(
1849                "Cancel-all",
1850                cancel_dispatch,
1851                &ws_client,
1852                &http_client,
1853                &emitter,
1854                clock,
1855            )
1856            .await;
1857
1858            Ok(())
1859        }) {
1860            for entry in &rejected_entries {
1861                emit_cancel_failure(
1862                    &self.emitter,
1863                    entry,
1864                    CommandFailure::not_sent(TASK_SHUTDOWN_DENIAL_REASON),
1865                    self.clock.get_time_ns(),
1866                );
1867            }
1868        }
1869
1870        Ok(())
1871    }
1872
1873    fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> anyhow::Result<()> {
1874        log::debug!("Batch cancelling orders: {cmd}");
1875
1876        if cmd.cancels.is_empty() {
1877            log::debug!("No orders to cancel in batch");
1878            return Ok(());
1879        }
1880
1881        let cache = self.core.cache();
1882        let entries: Vec<CancelEntry> = cmd
1883            .cancels
1884            .iter()
1885            .map(|c| CancelEntry {
1886                command_id: c.command_id,
1887                strategy_id: c.strategy_id,
1888                instrument_id: c.instrument_id,
1889                client_order_id: c.client_order_id,
1890                venue_order_id: c.venue_order_id,
1891                symbol: c.instrument_id.symbol.inner(),
1892                fast: can_fast_cancel_order(
1893                    cache
1894                        .order(&c.client_order_id)
1895                        .as_ref()
1896                        .map(|order| order.order_type()),
1897                ),
1898            })
1899            .collect();
1900
1901        let http_client = self.http_client.clone();
1902        let emitter = self.emitter.clone();
1903        let clock = self.clock;
1904        let ws_client = self.ws_client.clone();
1905
1906        let rejected_entries = entries.clone();
1907
1908        if !self.spawn_task("batch_cancel_orders", async move {
1909            let mut cancel_dispatch = CancelDispatch::new();
1910
1911            for entry in &entries {
1912                if !http_client.allows_instrument(entry.instrument_id) {
1913                    emit_cancel_failure(
1914                        &emitter,
1915                        entry,
1916                        CommandFailure::not_sent("Order outside execution product scope"),
1917                        clock.get_time_ns(),
1918                    );
1919                    continue;
1920                }
1921
1922                let asset = match http_client.get_asset_index_for_symbol(entry.symbol) {
1923                    Some(a) => a,
1924                    None => {
1925                        emit_cancel_failure(
1926                            &emitter,
1927                            entry,
1928                            CommandFailure::not_sent(format!(
1929                                "Asset index not found for symbol {}",
1930                                entry.symbol
1931                            )),
1932                            clock.get_time_ns(),
1933                        );
1934                        continue;
1935                    }
1936                };
1937
1938                if let Err(failure) = cancel_dispatch.push(entry, asset, &http_client) {
1939                    emit_cancel_failure(&emitter, entry, failure, clock.get_time_ns());
1940                }
1941            }
1942
1943            if cancel_dispatch.is_empty() {
1944                log::warn!("No valid cancel requests in batch");
1945                return Ok(());
1946            }
1947
1948            submit_cancel_dispatch(
1949                "Batch cancel",
1950                cancel_dispatch,
1951                &ws_client,
1952                &http_client,
1953                &emitter,
1954                clock,
1955            )
1956            .await;
1957
1958            Ok(())
1959        }) {
1960            for entry in &rejected_entries {
1961                emit_cancel_failure(
1962                    &self.emitter,
1963                    entry,
1964                    CommandFailure::not_sent(TASK_SHUTDOWN_DENIAL_REASON),
1965                    self.clock.get_time_ns(),
1966                );
1967            }
1968        }
1969
1970        Ok(())
1971    }
1972
1973    fn query_account(&self, _cmd: QueryAccount) -> anyhow::Result<()> {
1974        let http_client = self.http_client.clone();
1975        let account_address = self.get_account_address()?;
1976        let emitter = self.emitter.clone();
1977        let clock = self.clock;
1978
1979        self.spawn_task("query_account", async move {
1980            let perp_json = http_client
1981                .info_clearinghouse_state(&account_address)
1982                .await
1983                .context("failed to fetch clearinghouse state")?;
1984
1985            let perp_state: ClearinghouseState = serde_json::from_value(perp_json)
1986                .context("failed to deserialize clearinghouse state")?;
1987
1988            let spot_json = http_client
1989                .info_spot_clearinghouse_state(&account_address)
1990                .await
1991                .context("failed to fetch spot clearinghouse state")?;
1992            let spot_state: SpotClearinghouseState = serde_json::from_value(spot_json)
1993                .context("failed to deserialize spot clearinghouse state")?;
1994
1995            let abstraction = http_client
1996                .info_user_abstraction(&account_address)
1997                .await
1998                .context("failed to fetch user abstraction")?;
1999
2000            let ts_event = clock.get_time_ns();
2001            emit_account_state(&emitter, &perp_state, &spot_state, abstraction, ts_event)
2002        });
2003
2004        Ok(())
2005    }
2006
2007    fn query_order(&self, cmd: QueryOrder) -> anyhow::Result<()> {
2008        log::debug!("Querying order: {cmd}");
2009
2010        anyhow::ensure!(
2011            self.http_client.allows_instrument(cmd.instrument_id),
2012            "Order outside execution product scope"
2013        );
2014
2015        let client_order_id = cmd.client_order_id;
2016        let venue_order_id = match cmd.venue_order_id {
2017            Some(voi) => Some(voi),
2018            None => self.core.cache().venue_order_id(&client_order_id).copied(),
2019        };
2020
2021        let account_address = self.get_account_address()?;
2022        let http_client = self.http_client.clone();
2023        let emitter = self.emitter.clone();
2024        let dispatch_state = self.ws_dispatch_state.clone();
2025        let clock = self.clock;
2026
2027        let recovery_context = self
2028            .core
2029            .cache()
2030            .order(&client_order_id)
2031            .filter(|order| {
2032                order.account_id() == Some(self.core.account_id)
2033                    && order.instrument_id() == cmd.instrument_id
2034                    && order.strategy_id() == cmd.strategy_id
2035            })
2036            .and_then(|order| {
2037                query_order_recovery_context(&order, venue_order_id, &dispatch_state)
2038            });
2039
2040        self.spawn_task("query_order", async move {
2041            // Search open orders by cloid first so modify/cancel-replace
2042            // resolves to the live replacement rather than a stale cached oid.
2043            // Request errors here are logged, not propagated, so a transient
2044            // frontendOpenOrders failure does not abort the whole query.
2045            match http_client
2046                .request_order_status_report_by_client_order_id(&account_address, &client_order_id)
2047                .await
2048            {
2049                Ok(Some(report)) => {
2050                    promote_replacement_from_query(
2051                        &report,
2052                        &dispatch_state,
2053                        &emitter,
2054                        clock.get_time_ns(),
2055                    );
2056                    log::debug!("Queried order status for {client_order_id}");
2057                    emitter.send_order_status_report(report);
2058                    return Ok(());
2059                }
2060                Ok(None) => {}
2061                Err(e) => {
2062                    log::warn!(
2063                        "Failed to query order status for {client_order_id}: {e}; falling back to oid lookup"
2064                    );
2065                }
2066            }
2067
2068            let result = if let Some(venue_order_id) = venue_order_id {
2069                let oid: u64 = match venue_order_id.as_str().parse() {
2070                    Ok(oid) => oid,
2071                    Err(e) => {
2072                        log::warn!("Failed to parse venue order ID {venue_order_id}: {e}");
2073                        return Ok(());
2074                    }
2075                };
2076
2077                http_client
2078                    .request_order_status_report(&account_address, oid)
2079                    .await
2080            } else {
2081                // An order closed before its acceptance arrived is only found by cloid
2082                http_client
2083                    .request_order_status_report_by_cloid(&account_address, &client_order_id)
2084                    .await
2085            };
2086
2087            match result {
2088                Ok(Some(mut report)) => {
2089                    if is_inflight_modify_old_leg_cancel(
2090                        &dispatch_state,
2091                        &client_order_id,
2092                        &report,
2093                    ) {
2094                        log::debug!(
2095                            "Suppressing stale old-leg Canceled for {client_order_id}: modify in flight"
2096                        );
2097                    } else {
2098                        clamp_reduce_only_report_to_fills(&http_client, &account_address, &mut report)
2099                            .await;
2100
2101                        if let Some(context) = recovery_context {
2102                            recover_query_order_fills(
2103                                &http_client,
2104                                &account_address,
2105                                &report,
2106                                &context,
2107                                venue_order_id,
2108                                &dispatch_state,
2109                                &emitter,
2110                            )
2111                            .await;
2112                        }
2113
2114                        attach_known_client_order_id(&mut report, client_order_id);
2115                        log::debug!(
2116                            "Queried order status for {client_order_id} with oid {}",
2117                            report.venue_order_id
2118                        );
2119                        emitter.send_order_status_report(report);
2120                    }
2121                }
2122                Ok(None) => {
2123                    log::debug!("No order status report found for {client_order_id}");
2124                }
2125                Err(e) => {
2126                    log::warn!("Failed to query order status for {client_order_id}: {e}");
2127                }
2128            }
2129
2130            Ok(())
2131        });
2132
2133        Ok(())
2134    }
2135
2136    async fn connect(&mut self) -> anyhow::Result<()> {
2137        if self.core.is_connected() && self.pending_tasks.is_open() && self.session_tasks.is_open()
2138        {
2139            return Ok(());
2140        }
2141
2142        log::info!("Connecting Hyperliquid execution client");
2143
2144        if !self.pending_tasks.is_open() || !self.session_tasks.is_open() {
2145            self.teardown_partial_connect().await?;
2146            self.pending_tasks
2147                .start_generation()
2148                .map_err(|e| anyhow::anyhow!("Failed to start Hyperliquid task generation: {e}"))?;
2149            self.session_tasks.start_generation().map_err(|e| {
2150                anyhow::anyhow!("Failed to start Hyperliquid execution session generation: {e}")
2151            })?;
2152        }
2153        let ws_client = self.ws_client.clone();
2154        let setup_guard =
2155            TaskGroupGuard::new(&[&self.session_tasks, &self.pending_tasks], move || {
2156                ws_client.begin_shutdown();
2157            });
2158
2159        self.ensure_instruments_initialized_async().await?;
2160        let ready_bracket_parents = self.restore_staged_brackets();
2161
2162        let setup = async {
2163            self.start_scheduled_cancel().await?;
2164            self.start_ws_stream().await
2165        }
2166        .await;
2167
2168        if let Err(e) = setup {
2169            if let Err(teardown_error) = self.teardown_partial_connect().await {
2170                return Err(e.context(format!(
2171                    "Hyperliquid execution startup teardown failed: {teardown_error}"
2172                )));
2173            }
2174            return Err(e);
2175        }
2176
2177        // Post-WS setup: if any step fails, tear down WS before returning
2178        if let Err(e) = self.await_account_registered(30.0).await {
2179            log::warn!("Connect failed after WS started, tearing down: {e}");
2180            if let Err(teardown_error) = self.teardown_partial_connect().await {
2181                return Err(e.context(format!(
2182                    "Hyperliquid execution startup teardown failed: {teardown_error}"
2183                )));
2184            }
2185            return Err(e);
2186        }
2187
2188        let session_spawner = self
2189            .session_tasks
2190            .spawner()
2191            .map_err(|e| anyhow::anyhow!("Hyperliquid session task admission is closed: {e}"))?;
2192
2193        for parent_id in ready_bracket_parents {
2194            if let Some(children) = self.staged_brackets.lock().activate(&parent_id) {
2195                spawn_staged_children(
2196                    children,
2197                    &self.emitter,
2198                    &self.ws_client,
2199                    &self.http_client,
2200                    self.ws_dispatch_state.clone(),
2201                    self.staged_brackets.clone(),
2202                    self.http_client.builder_attribution(),
2203                    self.clock,
2204                    &session_spawner,
2205                );
2206            }
2207        }
2208
2209        if let Err(e) = self.start_outcome_settlement_poll() {
2210            log::warn!("Outcome settlement polling not started: {e}");
2211        }
2212
2213        self.core.set_connected();
2214        setup_guard.disarm();
2215
2216        log::info!("Connected: client_id={}", self.core.client_id);
2217        Ok(())
2218    }
2219
2220    async fn disconnect(&mut self) -> anyhow::Result<()> {
2221        log::info!("Disconnecting Hyperliquid execution client");
2222
2223        self.teardown_partial_connect().await?;
2224
2225        log::info!("Disconnected: client_id={}", self.core.client_id);
2226        Ok(())
2227    }
2228
2229    fn generate_order_status_report_task(
2230        &self,
2231        cmd: &GenerateOrderStatusReport,
2232    ) -> Option<ExecutionReportTask<Option<OrderStatusReport>>> {
2233        let client = self.report_client();
2234        let cached_oid = self.cached_report_oid(cmd);
2235        let command = cmd.clone();
2236        let dispatch_state = self.ws_dispatch_state.clone();
2237        let emitter = self.emitter.clone();
2238        let clock = self.clock;
2239        let client_order_id = cmd.client_order_id;
2240        Some(ExecutionReportTask::new(
2241            async move {
2242                client?
2243                    .collect_order_status_report(&command, cached_oid)
2244                    .await
2245            },
2246            move |report| {
2247                finish_order_status_report(
2248                    report,
2249                    client_order_id,
2250                    &dispatch_state,
2251                    &emitter,
2252                    clock.get_time_ns(),
2253                )
2254            },
2255        ))
2256    }
2257
2258    fn generate_order_status_reports_task(
2259        &self,
2260        cmd: &GenerateOrderStatusReports,
2261    ) -> Option<ExecutionReportTask<Vec<OrderStatusReport>>> {
2262        let client = self.report_client();
2263        let command = cmd.clone();
2264        Some(ExecutionReportTask::new(
2265            async move { client?.collect_order_status_reports(&command).await },
2266            Ok,
2267        ))
2268    }
2269
2270    fn generate_fill_reports_task(
2271        &self,
2272        cmd: &GenerateFillReports,
2273    ) -> Option<ExecutionReportTask<Vec<FillReport>>> {
2274        let client = self.report_client();
2275        let core = self.core.clone();
2276        let command = cmd.clone();
2277        Some(ExecutionReportTask::new(
2278            async move { client?.collect_fill_reports(command).await },
2279            move |reports| Ok(finish_fill_reports(&core, reports)),
2280        ))
2281    }
2282
2283    fn generate_position_status_reports_task(
2284        &self,
2285        cmd: &GeneratePositionStatusReports,
2286    ) -> Option<ExecutionReportTask<Vec<PositionStatusReport>>> {
2287        let client = self.report_client();
2288        let command = cmd.clone();
2289        Some(ExecutionReportTask::new(
2290            async move { client?.collect_position_status_reports(&command).await },
2291            Ok,
2292        ))
2293    }
2294
2295    async fn generate_order_status_report(
2296        &self,
2297        cmd: &GenerateOrderStatusReport,
2298    ) -> anyhow::Result<Option<OrderStatusReport>> {
2299        let report = self
2300            .report_client()?
2301            .collect_order_status_report(cmd, self.cached_report_oid(cmd))
2302            .await?;
2303        finish_order_status_report(
2304            report,
2305            cmd.client_order_id,
2306            &self.ws_dispatch_state,
2307            &self.emitter,
2308            self.clock.get_time_ns(),
2309        )
2310    }
2311
2312    async fn generate_order_status_reports(
2313        &self,
2314        cmd: &GenerateOrderStatusReports,
2315    ) -> anyhow::Result<Vec<OrderStatusReport>> {
2316        self.report_client()?
2317            .collect_order_status_reports(cmd)
2318            .await
2319    }
2320
2321    async fn generate_fill_reports(
2322        &self,
2323        cmd: GenerateFillReports,
2324    ) -> anyhow::Result<Vec<FillReport>> {
2325        let reports = self.report_client()?.collect_fill_reports(cmd).await?;
2326        Ok(finish_fill_reports(&self.core, reports))
2327    }
2328
2329    async fn generate_position_status_reports(
2330        &self,
2331        cmd: &GeneratePositionStatusReports,
2332    ) -> anyhow::Result<Vec<PositionStatusReport>> {
2333        self.report_client()?
2334            .collect_position_status_reports(cmd)
2335            .await
2336    }
2337
2338    async fn generate_mass_status(
2339        &self,
2340        lookback_mins: Option<u64>,
2341    ) -> anyhow::Result<Option<ExecutionMassStatus>> {
2342        let ts_init = self.clock.get_time_ns();
2343        let account_address = self.get_account_address()?;
2344        self.http_client
2345            .merge_instruments(&self.instruments_pending);
2346
2347        let lookback_start = lookback_mins
2348            .map(DurationNanos::try_from_mins)
2349            .transpose()?
2350            .map(|lookback| ts_init.saturating_sub(lookback));
2351
2352        // Fetch history before fills, so the fills cover every fill a history row implies
2353        let historical_orders = self
2354            .http_client
2355            .info_historical_orders(&account_address)
2356            .await
2357            .context("failed to fetch historical orders for mass status")?;
2358        let fills_response = self
2359            .http_client
2360            .info_user_fills(&account_address)
2361            .await
2362            .context("failed to fetch fills for mass status")?;
2363        let fills_capped = fills_response.len() >= HYPERLIQUID_RECENT_HISTORY_LIMIT;
2364        let dexes = self
2365            .http_client
2366            .reconciliation_dexes_from_activity(&historical_orders, &fills_response)
2367            .await
2368            .context("failed to determine reconciliation dexes")?;
2369
2370        // The venue bounds both history endpoints to their most recent entries;
2371        // a saturated response may be truncated, so coverage is not provable
2372        let history_capped =
2373            historical_orders.len() >= HYPERLIQUID_RECENT_HISTORY_LIMIT || fills_capped;
2374
2375        let history_start = if history_capped {
2376            fills_response
2377                .iter()
2378                .map(|fill| UnixNanos::from(fill.time * 1_000_000))
2379                .min()
2380        } else {
2381            None
2382        };
2383
2384        if history_capped {
2385            log::warn!(
2386                "Mass-status history response at venue cap ({HYPERLIQUID_RECENT_HISTORY_LIMIT}): \
2387                 marking reports incomplete"
2388            );
2389        }
2390
2391        let order_sweep = self
2392            .http_client
2393            .request_order_status_reports_for_dexes(&account_address, None, &dexes)
2394            .await
2395            .context("failed to generate order status reports")?;
2396        let fill_sweep = self
2397            .http_client
2398            .fill_reports_from_response(fills_response, None)
2399            .context("failed to generate fill reports")?;
2400        let position_sweep = self
2401            .http_client
2402            .request_position_status_reports_for_dexes(&account_address, None, &dexes)
2403            .await
2404            .context("failed to generate position status reports")?;
2405
2406        // Per-order fill totals from the whole fill history, before any lookback trim, and only
2407        // when that history is complete
2408        let fill_totals = (fill_sweep.complete && !fills_capped)
2409            .then(|| fill_totals_by_order(&fill_sweep.reports));
2410
2411        let mut order_reports = order_sweep.reports;
2412        let mut fill_reports = fill_sweep.reports;
2413        let position_reports = position_sweep.reports;
2414        let mut reports_complete = order_sweep.complete
2415            && fill_sweep.complete
2416            && position_sweep.complete
2417            && !history_capped;
2418
2419        // Apply lookback filter to fills only (positions are current state,
2420        // and open orders must always be included for correct reconciliation)
2421        if let Some(start) = lookback_start {
2422            fill_reports.retain(|r| r.ts_event >= start);
2423        }
2424
2425        if !fill_reports.is_empty() {
2426            let filled_order_ids: ahash::AHashSet<_> = fill_reports
2427                .iter()
2428                .map(|report| report.venue_order_id)
2429                .collect();
2430            let open_order_ids: ahash::AHashSet<_> = order_reports
2431                .iter()
2432                .map(|report| report.venue_order_id)
2433                .collect();
2434            let historical_sweep = self
2435                .http_client
2436                .historical_order_status_reports_from_response(historical_orders, None)
2437                .context("failed to generate historical order status reports")?;
2438            reports_complete &= historical_sweep.complete;
2439            let mut historical_reports = historical_sweep.reports;
2440            historical_reports.retain(|report| {
2441                filled_order_ids.contains(&report.venue_order_id)
2442                    && !open_order_ids.contains(&report.venue_order_id)
2443            });
2444
2445            if let Some(fill_totals) = &fill_totals {
2446                clamp_filled_reports_to_fills(&mut historical_reports, fill_totals);
2447            }
2448            order_reports.extend(historical_reports);
2449        }
2450
2451        let mut mass_status = ExecutionMassStatus::new(
2452            self.core.client_id,
2453            self.core.account_id,
2454            self.core.venue,
2455            ts_init,
2456            None,
2457        );
2458        mass_status.set_report_window(lookback_start.or(history_start), reports_complete);
2459        mass_status.add_order_reports(order_reports);
2460        mass_status.add_fill_reports(fill_reports);
2461        mass_status.add_position_reports(position_reports);
2462
2463        log::info!(
2464            "Generated mass status: {} orders, {} fills, {} positions",
2465            mass_status.order_reports().len(),
2466            mass_status.fill_reports().len(),
2467            mass_status.position_reports().len(),
2468        );
2469
2470        Ok(Some(mass_status))
2471    }
2472}
2473
2474struct HyperliquidReportClient {
2475    http_client: HyperliquidHttpClient,
2476    account_address: String,
2477}
2478
2479impl HyperliquidReportClient {
2480    async fn collect_order_status_report(
2481        &self,
2482        cmd: &GenerateOrderStatusReport,
2483        cached_oid: Option<u64>,
2484    ) -> anyhow::Result<CollectedOrderReport> {
2485        anyhow::ensure!(
2486            cmd.instrument_id
2487                .is_none_or(|id| self.http_client.allows_instrument(id)),
2488            "Instrument outside execution product scope"
2489        );
2490
2491        let account_address = &self.account_address;
2492
2493        if cmd.venue_order_id.is_none() && cmd.client_order_id.is_none() {
2494            log::warn!(
2495                "Cannot generate order status report without venue_order_id or client_order_id"
2496            );
2497            return Ok(CollectedOrderReport::NotFound);
2498        }
2499
2500        // Search open orders by cloid first when supplied. Hyperliquid modify
2501        // produces a new venue oid while preserving cloid, so a cached oid can
2502        // point at the canceled leg rather than the live replacement.
2503        let mut cloid_lookup_error = None;
2504
2505        if let Some(client_order_id) = &cmd.client_order_id {
2506            match self
2507                .http_client
2508                .request_order_status_report_by_client_order_id(account_address, client_order_id)
2509                .await
2510            {
2511                Ok(Some(report)) => {
2512                    log::debug!("Generated order status report for {client_order_id}");
2513                    return Ok(CollectedOrderReport::Cloid(report));
2514                }
2515                Ok(None) => {}
2516                Err(e) => {
2517                    log::warn!(
2518                        "Failed to generate order status report for {client_order_id}: {e}; \
2519                         falling back to oid lookup"
2520                    );
2521                    cloid_lookup_error = Some(anyhow::anyhow!(e));
2522                }
2523            }
2524        }
2525
2526        let oid = match cmd.venue_order_id {
2527            Some(venue_order_id) => Some(
2528                venue_order_id
2529                    .as_str()
2530                    .parse::<u64>()
2531                    .context("failed to parse venue_order_id as oid")?,
2532            ),
2533            None => cached_oid,
2534        };
2535
2536        let result = match (oid, &cmd.client_order_id) {
2537            (Some(oid), _) => {
2538                self.http_client
2539                    .request_order_status_report(account_address, oid)
2540                    .await
2541            }
2542            // An order closed before its acceptance arrived is only found by cloid
2543            (None, Some(client_order_id)) => {
2544                self.http_client
2545                    .request_order_status_report_by_cloid(account_address, client_order_id)
2546                    .await
2547            }
2548            (None, None) => Ok(None),
2549        };
2550
2551        let mut report = result.context("failed to generate order status report")?;
2552        if report.is_none()
2553            && let Some(e) = cloid_lookup_error
2554        {
2555            return Err(e.context("cloid lookup failed and status lookup found no order"));
2556        }
2557
2558        if let Some(report) = &mut report
2559            && let Some(client_order_id) = cmd.client_order_id
2560        {
2561            attach_known_client_order_id(report, client_order_id);
2562        }
2563
2564        if let Some(report) = &mut report {
2565            clamp_reduce_only_report_to_fills(&self.http_client, account_address, report).await;
2566        }
2567
2568        if let Some(report) = &report {
2569            log::debug!(
2570                "Generated order status report for oid {}",
2571                report.venue_order_id
2572            );
2573        } else if let Some(oid) = oid {
2574            log::debug!("No order status report found for oid {oid}");
2575        } else {
2576            log::debug!("No order status report found for {:?}", cmd.client_order_id);
2577        }
2578
2579        Ok(report.map_or(CollectedOrderReport::NotFound, CollectedOrderReport::Oid))
2580    }
2581
2582    async fn collect_order_status_reports(
2583        &self,
2584        cmd: &GenerateOrderStatusReports,
2585    ) -> anyhow::Result<Vec<OrderStatusReport>> {
2586        let account_address = &self.account_address;
2587
2588        let mut reports = self
2589            .http_client
2590            .request_order_status_reports(account_address, cmd.instrument_id)
2591            .await
2592            .context("failed to generate order status reports")?;
2593
2594        retain_order_status_reports(&mut reports, cmd);
2595
2596        log::debug!("Generated {} order status reports", reports.len());
2597        Ok(reports)
2598    }
2599
2600    async fn collect_fill_reports(
2601        &self,
2602        cmd: GenerateFillReports,
2603    ) -> anyhow::Result<Vec<FillReport>> {
2604        let account_address = &self.account_address;
2605
2606        let reports = self
2607            .http_client
2608            .request_fill_reports(account_address, cmd.instrument_id)
2609            .await
2610            .context("failed to generate fill reports")?;
2611
2612        let reports = if let (Some(start), Some(end)) = (cmd.start, cmd.end) {
2613            reports
2614                .into_iter()
2615                .filter(|r| r.ts_event >= start && r.ts_event <= end)
2616                .collect()
2617        } else if let Some(start) = cmd.start {
2618            reports
2619                .into_iter()
2620                .filter(|r| r.ts_event >= start)
2621                .collect()
2622        } else if let Some(end) = cmd.end {
2623            reports.into_iter().filter(|r| r.ts_event <= end).collect()
2624        } else {
2625            reports
2626        };
2627
2628        log::debug!("Generated {} fill reports", reports.len());
2629        Ok(reports)
2630    }
2631
2632    async fn collect_position_status_reports(
2633        &self,
2634        cmd: &GeneratePositionStatusReports,
2635    ) -> anyhow::Result<Vec<PositionStatusReport>> {
2636        let account_address = &self.account_address;
2637
2638        let reports = self
2639            .http_client
2640            .request_position_status_reports(account_address, cmd.instrument_id)
2641            .await
2642            .context("failed to generate position status reports")?;
2643
2644        log::debug!("Generated {} position status reports", reports.len());
2645        Ok(reports)
2646    }
2647}
2648
2649fn finish_fill_reports(
2650    core: &ExecutionClientCore,
2651    mut reports: Vec<FillReport>,
2652) -> Vec<FillReport> {
2653    let cache = core.cache();
2654
2655    // Unmapped fills must still match retained position fills after their order is purged
2656    for report in &mut reports {
2657        report.client_order_id = cache.client_order_id(&report.venue_order_id).copied();
2658    }
2659
2660    reports
2661}
2662
2663enum CollectedOrderReport {
2664    Cloid(OrderStatusReport),
2665    Oid(OrderStatusReport),
2666    NotFound,
2667}
2668
2669fn finish_order_status_report(
2670    collected: CollectedOrderReport,
2671    client_order_id: Option<ClientOrderId>,
2672    dispatch_state: &WsDispatchState,
2673    emitter: &ExecutionEventEmitter,
2674    ts_init: UnixNanos,
2675) -> anyhow::Result<Option<OrderStatusReport>> {
2676    let report = match &collected {
2677        CollectedOrderReport::Cloid(report) | CollectedOrderReport::Oid(report) => report,
2678        CollectedOrderReport::NotFound => return Ok(None),
2679    };
2680
2681    if let Some(client_order_id) = client_order_id.or(report.client_order_id) {
2682        let current_oid = dispatch_state.cached_venue_order_id(&client_order_id);
2683        let older_leg = current_oid
2684            .is_some_and(|current_oid| venue_oid(report.venue_order_id) < venue_oid(current_oid));
2685
2686        let superseded = match report.order_status {
2687            // Promoted legs still carry fill evidence; reconciliation suppresses their cancellation.
2688            OrderStatus::Canceled => {
2689                is_inflight_modify_old_leg_cancel(dispatch_state, &client_order_id, report)
2690            }
2691            OrderStatus::Accepted | OrderStatus::Triggered => older_leg,
2692            _ => false,
2693        };
2694
2695        if superseded {
2696            log::debug!(
2697                "Suppressing {} for superseded leg on {client_order_id}",
2698                report.order_status
2699            );
2700            anyhow::bail!("order status report for superseded leg on {client_order_id}");
2701        }
2702    }
2703
2704    Ok(match collected {
2705        CollectedOrderReport::Cloid(report) => {
2706            promote_replacement_from_query(&report, dispatch_state, emitter, ts_init);
2707            Some(report)
2708        }
2709        CollectedOrderReport::Oid(report) => Some(report),
2710        CollectedOrderReport::NotFound => None,
2711    })
2712}
2713
2714// Mass status clamps a reduce-only `Filled` report to its fills from its own fill sweep. The
2715// single-order lookups have no fills, so fetch them under the same rules; a failed fetch, a
2716// history at the venue cap, or an incomplete history leaves the venue report as it is
2717async fn clamp_reduce_only_report_to_fills(
2718    http_client: &HyperliquidHttpClient,
2719    account_address: &str,
2720    report: &mut OrderStatusReport,
2721) {
2722    if report.order_status != OrderStatus::Filled || !report.reduce_only {
2723        return;
2724    }
2725
2726    let venue_order_id = report.venue_order_id;
2727    let fills_response = match http_client.info_user_fills(account_address).await {
2728        Ok(fills) => fills,
2729        Err(e) => {
2730            log::warn!(
2731                "Failed to fetch fills for reduce-only order {venue_order_id}, keeping venue quantity: {e}"
2732            );
2733            return;
2734        }
2735    };
2736
2737    if fills_response.len() >= HYPERLIQUID_RECENT_HISTORY_LIMIT {
2738        log::debug!(
2739            "Fill history at venue cap, keeping venue quantity for reduce-only order {venue_order_id}"
2740        );
2741        return;
2742    }
2743
2744    match http_client.fill_reports_from_response(fills_response, Some(report.instrument_id)) {
2745        Ok(fill_sweep) if fill_sweep.complete => {
2746            let fill_totals = fill_totals_by_order(&fill_sweep.reports);
2747            clamp_filled_reports_to_fills(std::slice::from_mut(report), &fill_totals);
2748        }
2749        Ok(_) => log::debug!(
2750            "Fill history incomplete, keeping venue quantity for reduce-only order {venue_order_id}"
2751        ),
2752        Err(e) => log::warn!(
2753            "Failed to parse fills for reduce-only order {venue_order_id}, keeping venue quantity: {e}"
2754        ),
2755    }
2756}
2757
2758fn fill_totals_by_order(fills: &[FillReport]) -> AHashMap<(InstrumentId, VenueOrderId), Decimal> {
2759    let mut totals: AHashMap<(InstrumentId, VenueOrderId), Decimal> = AHashMap::new();
2760    for fill in fills {
2761        *totals
2762            .entry((fill.instrument_id, fill.venue_order_id))
2763            .or_default() += fill.last_qty.as_decimal();
2764    }
2765    totals
2766}
2767
2768// The venue reports a reduce-only order `filled` with nothing remaining once it closes the
2769// position, even when the position was smaller than the order, so the row's filled quantity
2770// exceeds the order's fills and the core would try to infer the missing fill. Clamp such a
2771// `Filled` report to its fills. Other orders are left alone and logged, since a shortfall there
2772// is not a known venue shape.
2773fn clamp_filled_reports_to_fills(
2774    reports: &mut [OrderStatusReport],
2775    fill_totals: &AHashMap<(InstrumentId, VenueOrderId), Decimal>,
2776) {
2777    for report in reports {
2778        if report.order_status != OrderStatus::Filled {
2779            continue;
2780        }
2781
2782        let Some(&fill_total) = fill_totals.get(&(report.instrument_id, report.venue_order_id))
2783        else {
2784            continue;
2785        };
2786
2787        if fill_total.is_zero() || fill_total >= report.filled_qty.as_decimal() {
2788            continue;
2789        }
2790
2791        if !report.reduce_only {
2792            log::warn!(
2793                "Filled order {} reports {} filled but its fills total {fill_total}, leaving as is",
2794                report.venue_order_id,
2795                report.filled_qty,
2796            );
2797            continue;
2798        }
2799
2800        let Ok(filled_qty) = Quantity::from_decimal_dp(fill_total, report.filled_qty.precision)
2801        else {
2802            log::warn!(
2803                "Cannot clamp filled order {} to its fill total {fill_total}",
2804                report.venue_order_id,
2805            );
2806            continue;
2807        };
2808
2809        log::info!(
2810            "Clamping reduce-only order {} to its fills: venue quantity {}, filled {filled_qty}",
2811            report.venue_order_id,
2812            report.quantity,
2813        );
2814        report.quantity = filled_qty;
2815        report.filled_qty = filled_qty;
2816    }
2817}
2818
2819impl HyperliquidExecutionClient {
2820    async fn start_ws_stream(&self) -> anyhow::Result<()> {
2821        // Must match REST queries; mismatch silently drops fills on agent wallets
2822        let subscription_address = self.get_account_address()?;
2823
2824        let mut ws_client = self.ws_client.clone();
2825
2826        let ts_start = self.clock.get_time_ns();
2827        ws_client.connect().await?;
2828        if let Err(e) = ws_client
2829            .subscribe_order_updates(&subscription_address)
2830            .await
2831        {
2832            let _ = ws_client.disconnect().await;
2833            return Err(e);
2834        }
2835
2836        if let Err(e) = ws_client.subscribe_user_events(&subscription_address).await {
2837            let _ = ws_client.disconnect().await;
2838            return Err(e);
2839        }
2840
2841        let (mut perp_state, mut spot_state, abstraction) = self.refresh_account_state().await?;
2842        ws_client
2843            .subscribe_account_state(
2844                &subscription_address,
2845                abstraction == HyperliquidAccountAbstraction::PortfolioMargin,
2846            )
2847            .await?;
2848        log::debug!("Subscribed to Hyperliquid execution updates for {subscription_address}");
2849
2850        let emitter = self.emitter.clone();
2851        let dispatch_state = self.ws_dispatch_state.clone();
2852        let staged_brackets = self.staged_brackets.clone();
2853        let http_client = self.http_client.clone();
2854        let builder = self.http_client.builder_attribution();
2855        let clock = self.clock;
2856        let session_spawner = self
2857            .session_tasks
2858            .spawner()
2859            .map_err(|e| anyhow::anyhow!("Hyperliquid session task admission is closed: {e}"))?;
2860
2861        self.session_tasks.spawn(async move {
2862            // Cloids for external / untracked orders that reach a terminal
2863            // state: we evict their mapping immediately so long-running
2864            // sessions do not leak. Tracked orders clear their own cloid
2865            // mapping from the dispatch `cleanup_terminal` path below.
2866            //
2867            // For a tracked order that hits a status-only `FILLED` marker
2868            // without an accompanying fill, we defer the cloid cleanup until
2869            // the matching `FillReport` arrives so partial fills do not lose
2870            // their `client_order_id` link. The bounded FIFO cache keeps
2871            // orphaned entries from growing unbounded.
2872            let mut pending_filled_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
2873
2874            // Venue time of the latest delivered report (the stream start before any), so a
2875            // stalled stream cannot push the recovery window past events lost after it.
2876            let mut ts_last_report = ts_start;
2877            let mut recovery_window: Option<RecoveryWindow> = None;
2878            let mut reconnect_generation = 0;
2879            let mut recovered_reports = None;
2880            let (follow_up_tx, mut follow_up_rx) =
2881                tokio::sync::mpsc::unbounded_channel::<FollowUpHistory>();
2882
2883            loop {
2884                let event = next_execution_event(
2885                    &mut recovered_reports,
2886                    &mut recovery_window,
2887                    &mut follow_up_rx,
2888                    &mut ws_client,
2889                    &http_client,
2890                    &dispatch_state,
2891                )
2892                .await;
2893
2894                match event {
2895                    Some(msg) => match msg {
2896                        NautilusWsMessage::ExecutionReports(reports) => {
2897                            for report in reports {
2898                                let instrument_id = match &report {
2899                                    ExecutionReport::Fill(report) => report.instrument_id,
2900                                    ExecutionReport::Order(report) => report.instrument_id,
2901                                };
2902
2903                                if !http_client.allows_instrument(instrument_id) {
2904                                    continue;
2905                                }
2906
2907                                ts_last_report = ts_last_report.max(ts_venue(&report));
2908
2909                                let staged_parent_fill = match &report {
2910                                    ExecutionReport::Fill(report) => report.client_order_id,
2911                                    ExecutionReport::Order(_) => None,
2912                                };
2913
2914                                let staged_parent_terminal = match &report {
2915                                    ExecutionReport::Order(report)
2916                                        if matches!(
2917                                            report.order_status,
2918                                            OrderStatus::Canceled
2919                                                | OrderStatus::Rejected
2920                                                | OrderStatus::Expired
2921                                        ) =>
2922                                    {
2923                                        report.client_order_id.map(|client_order_id| {
2924                                            (client_order_id, report.ts_last)
2925                                        })
2926                                    }
2927                                    _ => None,
2928                                };
2929
2930                                let active_child_terminal = match &report {
2931                                    ExecutionReport::Order(report)
2932                                        if matches!(
2933                                            report.order_status,
2934                                            OrderStatus::Filled
2935                                                | OrderStatus::Canceled
2936                                                | OrderStatus::Rejected
2937                                                | OrderStatus::Expired
2938                                        ) =>
2939                                    {
2940                                        report.client_order_id
2941                                    }
2942                                    ExecutionReport::Fill(report) => {
2943                                        report.client_order_id.filter(|client_order_id| {
2944                                            let Some(context) =
2945                                                dispatch_state.lookup_context(client_order_id)
2946                                            else {
2947                                                return false;
2948                                            };
2949                                            let previous = dispatch_state
2950                                                .previous_filled_qty(client_order_id)
2951                                                .unwrap_or_else(|| {
2952                                                    Quantity::zero(report.last_qty.precision)
2953                                                });
2954                                            previous + report.last_qty >= context.quantity
2955                                        })
2956                                    }
2957                                    _ => None,
2958                                };
2959
2960                                let active_child_fill = match &report {
2961                                    ExecutionReport::Fill(report) => {
2962                                        report.client_order_id.and_then(|client_order_id| {
2963                                            dispatch_state.lookup_context(&client_order_id).map(
2964                                                |context| {
2965                                                    (
2966                                                        client_order_id,
2967                                                        dispatch_state
2968                                                            .previous_filled_qty(&client_order_id)
2969                                                            .unwrap_or_else(|| {
2970                                                                Quantity::zero(
2971                                                                    report.last_qty.precision,
2972                                                                )
2973                                                            }),
2974                                                        context.quantity,
2975                                                    )
2976                                                },
2977                                            )
2978                                        })
2979                                    }
2980                                    ExecutionReport::Order(_) => None,
2981                                };
2982
2983                                let (terminal_skipped, corrective) = handle_execution_report(
2984                                    report,
2985                                    &dispatch_state,
2986                                    &emitter,
2987                                    &ws_client,
2988                                    &http_client,
2989                                    &mut pending_filled_cloids,
2990                                    clock.get_time_ns(),
2991                                );
2992
2993                                if let Some((cid, corrective)) = corrective {
2994                                    spawn_corrective_reduce(
2995                                        &ws_client,
2996                                        &http_client,
2997                                        &dispatch_state,
2998                                        cid,
2999                                        corrective,
3000                                        &session_spawner,
3001                                    );
3002                                }
3003
3004                                if let Some(parent_id) = staged_parent_fill
3005                                    && let Some(children) =
3006                                        staged_brackets.lock().activate(&parent_id)
3007                                {
3008                                    spawn_staged_children(
3009                                        children,
3010                                        &emitter,
3011                                        &ws_client,
3012                                        &http_client,
3013                                        dispatch_state.clone(),
3014                                        staged_brackets.clone(),
3015                                        builder.clone(),
3016                                        clock,
3017                                        &session_spawner,
3018                                    );
3019                                }
3020
3021                                if let Some((parent_id, ts_event)) =
3022                                    staged_parent_terminal.filter(|_| !terminal_skipped)
3023                                {
3024                                    let children =
3025                                        staged_brackets.lock().cancel_for_parent(&parent_id);
3026
3027                                    for child in children {
3028                                        emitter.emit_order_canceled(&child, None, ts_event);
3029                                    }
3030                                }
3031
3032                                if let Some((client_order_id, previous, quantity)) =
3033                                    active_child_fill
3034                                    && let Some(cumulative) =
3035                                        dispatch_state.previous_filled_qty(&client_order_id)
3036                                    && cumulative > previous
3037                                    && cumulative < quantity
3038                                {
3039                                    let sibling =
3040                                        staged_brackets.lock().active_sibling(&client_order_id);
3041
3042                                    if let Some(sibling) = sibling {
3043                                        spawn_active_sibling_resize(
3044                                            sibling,
3045                                            quantity - cumulative,
3046                                            &emitter,
3047                                            &ws_client,
3048                                            &http_client,
3049                                            &dispatch_state,
3050                                            &session_spawner,
3051                                        );
3052                                    }
3053                                }
3054
3055                                if let Some(client_order_id) =
3056                                    active_child_terminal.filter(|_| !terminal_skipped)
3057                                {
3058                                    let sibling = staged_brackets
3059                                        .lock()
3060                                        .take_active_sibling(&client_order_id);
3061
3062                                    if let Some(sibling) = sibling {
3063                                        spawn_active_sibling_cancel(
3064                                            sibling,
3065                                            &emitter,
3066                                            &ws_client,
3067                                            &http_client,
3068                                            &dispatch_state,
3069                                            &session_spawner,
3070                                        );
3071                                    }
3072                                }
3073                            }
3074                        }
3075                        NautilusWsMessage::ClearinghouseState(state) => {
3076                            emit_account_state(
3077                                &emitter,
3078                                &state,
3079                                &spot_state,
3080                                abstraction,
3081                                clock.get_time_ns(),
3082                            )
3083                            .inspect(|()| perp_state = state)
3084                            .unwrap_or_else(|e| log::error!("Failed to update account state: {e:#}"));
3085                        }
3086                        NautilusWsMessage::SpotState(state) => {
3087                            emit_account_state(
3088                                &emitter,
3089                                &perp_state,
3090                                &state,
3091                                abstraction,
3092                                clock.get_time_ns(),
3093                            )
3094                            .inspect(|()| spot_state = state)
3095                            .unwrap_or_else(|e| log::error!("Failed to update account state: {e:#}"));
3096                        }
3097                        NautilusWsMessage::Reconnected => {
3098                            log::info!("WebSocket reconnected");
3099
3100                            reconnect_generation += 1;
3101
3102                            let window = RecoveryWindow {
3103                                ts_start: recovery_window
3104                                    .map_or(ts_last_report, |window| window.ts_start),
3105                                generation: reconnect_generation,
3106                            };
3107
3108                            recovery_window = Some(window);
3109
3110                            recovered_reports = fetch_reconnect_reports(
3111                                &ws_client,
3112                                &http_client,
3113                                &dispatch_state,
3114                                &subscription_address,
3115                                window.ts_start,
3116                            )
3117                            .await
3118                            .inspect(|reports| {
3119                                log::info!(
3120                                    "Recovered {} execution reports missed while disconnected",
3121                                    reports.len(),
3122                                );
3123                            })
3124                            .inspect_err(|e| {
3125                                log::error!(
3126                                    "Failed to recover execution reports missed while disconnected: {e:#}"
3127                                );
3128                            })
3129                            .ok();
3130
3131                            spawn_follow_up_history_read(
3132                                &http_client,
3133                                &subscription_address,
3134                                window,
3135                                follow_up_tx.clone(),
3136                                &session_spawner,
3137                            );
3138                        }
3139                        NautilusWsMessage::Error(e) => {
3140                            log::warn!("WebSocket error: {e}");
3141                        }
3142                        NautilusWsMessage::Trades(_)
3143                        | NautilusWsMessage::Quote(_)
3144                        | NautilusWsMessage::Deltas(_)
3145                        | NautilusWsMessage::CompactBook { .. }
3146                        | NautilusWsMessage::Depth(_)
3147                        | NautilusWsMessage::BookInvalid { .. }
3148                        | NautilusWsMessage::Candle(_)
3149                        | NautilusWsMessage::MarkPrice(_)
3150                        | NautilusWsMessage::IndexPrice(_)
3151                        | NautilusWsMessage::FundingRate(_)
3152                        | NautilusWsMessage::CustomData(_) => {}
3153                    },
3154                    None => {
3155                        log::debug!("WebSocket next_event returned None, stream closed");
3156                        break;
3157                    }
3158                }
3159            }
3160        })?;
3161
3162        log::debug!("Hyperliquid WebSocket execution stream started");
3163        Ok(())
3164    }
3165}
3166
3167fn emit_account_state(
3168    emitter: &ExecutionEventEmitter,
3169    perp_state: &ClearinghouseState,
3170    spot_state: &SpotClearinghouseState,
3171    abstraction: HyperliquidAccountAbstraction,
3172    ts_event: UnixNanos,
3173) -> anyhow::Result<()> {
3174    let (balances, margins) =
3175        parse_combined_account_balances_and_margins(perp_state, spot_state, abstraction)
3176            .context("failed to parse combined account balances and margins")?;
3177    emitter.emit_account_state(balances, margins, true, ts_event, None);
3178    Ok(())
3179}
3180
3181async fn refresh_scheduled_cancel(
3182    http_client: &HyperliquidHttpClient,
3183    clock: &AtomicTime,
3184    timeout: Duration,
3185    refresh_interval: Duration,
3186) -> anyhow::Result<()> {
3187    let timeout_ms = u64::try_from(timeout.as_millis())?;
3188    let deadline = clock
3189        .get_time_ms()
3190        .checked_add(timeout_ms)
3191        .context("scheduled cancellation deadline overflows milliseconds")?;
3192
3193    tokio::time::timeout(
3194        refresh_interval,
3195        http_client.schedule_cancel(Some(deadline)),
3196    )
3197    .await
3198    .context("scheduled cancellation request timed out")??;
3199    Ok(())
3200}
3201
3202async fn next_execution_event(
3203    recovered_reports: &mut Option<Vec<ExecutionReport>>,
3204    recovery_window: &mut Option<RecoveryWindow>,
3205    follow_up_rx: &mut tokio::sync::mpsc::UnboundedReceiver<FollowUpHistory>,
3206    ws_client: &mut HyperliquidWebSocketClient,
3207    http_client: &HyperliquidHttpClient,
3208    dispatch_state: &WsDispatchState,
3209) -> Option<NautilusWsMessage> {
3210    // Recovered reports take the live path ahead of the messages queued behind the
3211    // reconnect, so dispatch sees events in venue order.
3212    if let Some(reports) = recovered_reports.take() {
3213        return Some(NautilusWsMessage::ExecutionReports(reports));
3214    }
3215
3216    // Released terminal reports take the same path, so bracket siblings react to them.
3217    // Follow-up history is built here, against the dispatch state it replays into
3218    let mut event = tokio::select! {
3219        event = ws_client.next_event() => event,
3220        released = dispatch_state.recv_released_cancels() => {
3221            Some(NautilusWsMessage::ExecutionReports(
3222                released.into_iter().map(ExecutionReport::Order).collect(),
3223            ))
3224        }
3225        Some((orders, fills, window)) = follow_up_rx.recv() => {
3226            let reports = reconnect_reports_from_history(
3227                fills,
3228                orders,
3229                window.ts_start.saturating_sub(RECONNECT_RECOVERY_MARGIN),
3230                ws_client,
3231                http_client,
3232                dispatch_state,
3233            )
3234            .inspect(|reports| {
3235                // An older read cannot settle a gap reopened by a newer reconnect
3236                if *recovery_window == Some(window) {
3237                    *recovery_window = None;
3238                }
3239
3240                log::info!(
3241                    "Recovered {} execution reports in the follow-up history read",
3242                    reports.len(),
3243                );
3244            })
3245            .inspect_err(|e| log::error!("Failed the follow-up history read: {e:#}"))
3246            .unwrap_or_default();
3247            Some(NautilusWsMessage::ExecutionReports(reports))
3248        }
3249    };
3250
3251    // A recovered fill can also arrive on the resumed stream, and bracket sibling handling
3252    // counts a fill before dispatch drops its duplicate.
3253    if let Some(NautilusWsMessage::ExecutionReports(reports)) = &mut event {
3254        reports.retain(|report| match report {
3255            ExecutionReport::Fill(fill) => !dispatch_state.trade_emitted(&fill.trade_id),
3256            ExecutionReport::Order(_) => true,
3257        });
3258    }
3259
3260    event
3261}
3262
3263fn ts_venue(report: &ExecutionReport) -> UnixNanos {
3264    match report {
3265        ExecutionReport::Order(report) => report.ts_last,
3266        ExecutionReport::Fill(report) => report.ts_event,
3267    }
3268}
3269
3270async fn fetch_reconnect_reports(
3271    ws_client: &HyperliquidWebSocketClient,
3272    http_client: &HyperliquidHttpClient,
3273    dispatch_state: &WsDispatchState,
3274    account_address: &str,
3275    ts_last_report: UnixNanos,
3276) -> anyhow::Result<Vec<ExecutionReport>> {
3277    // History read before the venue resumes both streams could miss an event in between
3278    if let Err(e) = ws_client
3279        .wait_for_subscriptions_confirmed(RECONNECT_SUBSCRIPTION_TIMEOUT)
3280        .await
3281    {
3282        log::warn!("{e}; recovering missed execution reports regardless");
3283    }
3284
3285    let (orders, fills) = read_history(http_client, account_address).await?;
3286
3287    reconnect_reports_from_history(
3288        fills,
3289        orders,
3290        ts_last_report.saturating_sub(RECONNECT_RECOVERY_MARGIN),
3291        ws_client,
3292        http_client,
3293        dispatch_state,
3294    )
3295}
3296
3297#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3298struct RecoveryWindow {
3299    ts_start: UnixNanos,
3300    generation: u64,
3301}
3302
3303// Raw history a follow-up read fetched, with the recovery window it can settle
3304type FollowUpHistory = (
3305    Vec<HyperliquidOrderStatusEntry>,
3306    HyperliquidFills,
3307    RecoveryWindow,
3308);
3309
3310// The stream loop builds and replays the reports, so a slow read never holds back stream updates
3311fn spawn_follow_up_history_read(
3312    http_client: &HyperliquidHttpClient,
3313    account_address: &str,
3314    window: RecoveryWindow,
3315    sender: tokio::sync::mpsc::UnboundedSender<FollowUpHistory>,
3316    task_spawner: &TaskSpawner,
3317) {
3318    let http_client = http_client.clone();
3319    let account_address = account_address.to_string();
3320
3321    if let Err(e) = task_spawner.spawn(async move {
3322        tokio::time::sleep(RECONNECT_FOLLOW_UP_DELAY).await;
3323
3324        match read_history(&http_client, &account_address).await {
3325            Ok((orders, fills)) => {
3326                let _ = sender.send((orders, fills, window));
3327            }
3328            Err(e) => log::error!("Failed the follow-up history read: {e:#}"),
3329        }
3330    }) {
3331        log::warn!("Skipping Hyperliquid follow-up history read after shutdown began: {e}");
3332    }
3333}
3334
3335// Orders first: a fill precedes its order's terminal status, so the later fill read holds
3336// every fill behind a terminal status in the order snapshot.
3337async fn read_history(
3338    http_client: &HyperliquidHttpClient,
3339    account_address: &str,
3340) -> anyhow::Result<(Vec<HyperliquidOrderStatusEntry>, HyperliquidFills)> {
3341    let orders = http_client
3342        .info_historical_orders(account_address)
3343        .await
3344        .context("failed to fetch historical orders")?;
3345    let fills = http_client
3346        .info_user_fills(account_address)
3347        .await
3348        .context("failed to fetch user fills")?;
3349
3350    Ok((orders, fills))
3351}
3352
3353fn reconnect_reports_from_history(
3354    mut fills: HyperliquidFills,
3355    mut orders: Vec<HyperliquidOrderStatusEntry>,
3356    ts_start: UnixNanos,
3357    ws_client: &HyperliquidWebSocketClient,
3358    http_client: &HyperliquidHttpClient,
3359    dispatch_state: &WsDispatchState,
3360) -> anyhow::Result<Vec<ExecutionReport>> {
3361    let start_ms = ts_start.as_millis();
3362    fills.retain(|fill| fill.time >= start_ms);
3363    orders.retain(|entry| entry.status_timestamp >= start_ms);
3364
3365    let fill_cloids: AHashMap<VenueOrderId, Ustr> = fills
3366        .iter()
3367        .filter_map(|fill| {
3368            let cloid = fill.cloid.as_deref()?;
3369            Some((VenueOrderId::new(fill.oid.to_string()), Ustr::from(cloid)))
3370        })
3371        .collect();
3372
3373    let mut reports = Vec::new();
3374
3375    for mut report in http_client.fill_reports_from_response(fills, None)?.reports {
3376        if dispatch_state.trade_emitted(&report.trade_id) {
3377            continue;
3378        }
3379
3380        report.client_order_id = fill_cloids
3381            .get(&report.venue_order_id)
3382            .and_then(|cloid| ws_client.get_cloid_mapping(cloid));
3383        reports.push(ExecutionReport::Fill(report));
3384    }
3385
3386    let order_reports = http_client
3387        .historical_order_status_reports_from_response(orders, None)?
3388        .reports
3389        .into_iter()
3390        .map(|mut report| {
3391            report.client_order_id = report
3392                .client_order_id
3393                .map(|cloid| ws_client.get_cloid_mapping(&cloid.inner()).unwrap_or(cloid));
3394            report
3395        })
3396        .collect();
3397
3398    // The recovered fills carry the fill state; dispatch takes nothing from the marker
3399    reports.extend(
3400        resolve_order_legs(order_reports, dispatch_state)
3401            .into_iter()
3402            .filter(|report| report.order_status != OrderStatus::Filled)
3403            .map(ExecutionReport::Order),
3404    );
3405
3406    // A leg's opening status precedes its fills, which precede its closing status. Legs placed in
3407    // one block share a timestamp, so within a millisecond each leg's events stay together in
3408    // placement order
3409    reports.sort_by_key(|report| match report {
3410        ExecutionReport::Order(report) if report.order_status.is_closed() => {
3411            (report.ts_last, venue_oid(report.venue_order_id), 2)
3412        }
3413        ExecutionReport::Order(report) => (report.ts_last, venue_oid(report.venue_order_id), 0),
3414        ExecutionReport::Fill(report) => (report.ts_event, venue_oid(report.venue_order_id), 1),
3415    });
3416
3417    Ok(reports)
3418}
3419
3420// History holds only the latest status of each venue order, so the legs of a modify read as already
3421// closed and a replacement the client never saw accepted shows no opening. Replays each tracked
3422// order's chain as the live stream would: every leg newer than the bound one opens in creation
3423// order ahead of its fills, so dispatch promotes through the chain one modify at a time, and only
3424// the newest leg's own status follows (an older leg's close is its cancel-replace).
3425fn resolve_order_legs(
3426    reports: Vec<OrderStatusReport>,
3427    dispatch_state: &WsDispatchState,
3428) -> Vec<OrderStatusReport> {
3429    let newest_legs = newest_resting_legs(&reports, dispatch_state);
3430    let mut resolved = Vec::with_capacity(reports.len());
3431
3432    for report in reports {
3433        let Some((client_order_id, newest)) = report
3434            .client_order_id
3435            .and_then(|id| newest_legs.get(&id).map(|newest| (id, *newest)))
3436        else {
3437            resolved.push(report);
3438            continue;
3439        };
3440
3441        if report.order_status == OrderStatus::Canceled {
3442            dispatch_state.record_closed_venue_order_id(report.venue_order_id);
3443        }
3444
3445        let bound = dispatch_state.cached_venue_order_id(&client_order_id);
3446        let unseen = bound.is_none_or(|bound| venue_oid(bound) < venue_oid(report.venue_order_id));
3447
3448        // An open row is its own opening, and a rejected row never rested, as when a modify
3449        // fails to place its replacement
3450        if unseen
3451            && !matches!(
3452                report.order_status,
3453                OrderStatus::Accepted | OrderStatus::Rejected
3454            )
3455        {
3456            resolved.push(opening_report(&report));
3457        }
3458
3459        if report.venue_order_id != newest {
3460            continue;
3461        }
3462
3463        resolved.push(report);
3464    }
3465
3466    resolved
3467}
3468
3469fn newest_resting_legs(
3470    reports: &[OrderStatusReport],
3471    dispatch_state: &WsDispatchState,
3472) -> AHashMap<ClientOrderId, VenueOrderId> {
3473    let mut newest_legs: AHashMap<ClientOrderId, VenueOrderId> = AHashMap::new();
3474
3475    for report in reports {
3476        let Some(client_order_id) = report.client_order_id else {
3477            continue;
3478        };
3479
3480        if report.order_status == OrderStatus::Rejected
3481            || dispatch_state.lookup_context(&client_order_id).is_none()
3482        {
3483            continue;
3484        }
3485
3486        let newest = newest_legs
3487            .entry(client_order_id)
3488            .or_insert(report.venue_order_id);
3489
3490        if venue_oid(report.venue_order_id) > venue_oid(*newest) {
3491            *newest = report.venue_order_id;
3492        }
3493    }
3494
3495    newest_legs
3496}
3497
3498fn opening_report(report: &OrderStatusReport) -> OrderStatusReport {
3499    let mut opening = report.clone();
3500    opening.order_status = OrderStatus::Accepted;
3501    opening.filled_qty = Quantity::zero(report.filled_qty.precision);
3502    opening.avg_px = None;
3503    opening.ts_last = report.ts_accepted;
3504    opening.report_id = UUID4::new();
3505    opening
3506}
3507
3508#[derive(Debug, Clone)]
3509struct StagedBracketChild {
3510    order: OrderAny,
3511    request: HyperliquidExchangePlaceOrderRequest,
3512}
3513
3514#[derive(Debug, Default)]
3515struct StagedBracketState {
3516    children_by_parent: AHashMap<ClientOrderId, Vec<StagedBracketChild>>,
3517    active_children: AHashMap<ClientOrderId, StagedBracketChild>,
3518    active_siblings: AHashMap<ClientOrderId, ClientOrderId>,
3519}
3520
3521impl StagedBracketState {
3522    fn stage(&mut self, parent_id: ClientOrderId, children: Vec<StagedBracketChild>) {
3523        self.children_by_parent.insert(parent_id, children);
3524    }
3525
3526    fn activate(&mut self, parent_id: &ClientOrderId) -> Option<Vec<StagedBracketChild>> {
3527        let children = self.children_by_parent.remove(parent_id)?;
3528        self.track_active(&children);
3529
3530        Some(children)
3531    }
3532
3533    fn restore_active(&mut self, children: &[StagedBracketChild]) {
3534        self.track_active(children);
3535    }
3536
3537    fn track_active(&mut self, children: &[StagedBracketChild]) {
3538        let child_ids = children
3539            .iter()
3540            .map(|child| child.order.client_order_id())
3541            .collect::<Vec<_>>();
3542
3543        for child in children {
3544            let child_id = child.order.client_order_id();
3545            if let Some(sibling_id) = child
3546                .order
3547                .linked_order_ids()
3548                .and_then(|ids| ids.iter().find(|id| child_ids.contains(id)))
3549            {
3550                self.active_siblings.insert(child_id, *sibling_id);
3551            }
3552            self.active_children.insert(child_id, child.clone());
3553        }
3554    }
3555
3556    fn contains_parent(&self, parent_id: &ClientOrderId) -> bool {
3557        self.children_by_parent.contains_key(parent_id)
3558    }
3559
3560    fn cancel_child(&mut self, child_id: &ClientOrderId) -> Option<OrderAny> {
3561        let parent_id = self
3562            .children_by_parent
3563            .iter()
3564            .find_map(|(parent_id, children)| {
3565                children
3566                    .iter()
3567                    .any(|child| child.order.client_order_id() == *child_id)
3568                    .then_some(*parent_id)
3569            })?;
3570        let children = self.children_by_parent.get_mut(&parent_id)?;
3571        let index = children
3572            .iter()
3573            .position(|child| child.order.client_order_id() == *child_id)?;
3574        let child = children.remove(index);
3575
3576        if children.is_empty() {
3577            self.children_by_parent.remove(&parent_id);
3578        }
3579
3580        Some(child.order)
3581    }
3582
3583    fn cancel_for_parent(&mut self, parent_id: &ClientOrderId) -> Vec<OrderAny> {
3584        self.children_by_parent
3585            .remove(parent_id)
3586            .map_or_default(|children| children.into_iter().map(|child| child.order).collect())
3587    }
3588
3589    fn take_active_sibling(
3590        &mut self,
3591        client_order_id: &ClientOrderId,
3592    ) -> Option<StagedBracketChild> {
3593        self.active_children.remove(client_order_id);
3594        let sibling_id = self.active_siblings.remove(client_order_id)?;
3595        self.active_siblings.remove(&sibling_id);
3596        self.active_children.remove(&sibling_id)
3597    }
3598
3599    fn active_sibling(&self, client_order_id: &ClientOrderId) -> Option<StagedBracketChild> {
3600        self.active_siblings
3601            .get(client_order_id)
3602            .and_then(|sibling_id| self.active_children.get(sibling_id))
3603            .cloned()
3604    }
3605}
3606
3607fn query_order_recovery_context(
3608    order: &OrderAny,
3609    venue_order_id: Option<VenueOrderId>,
3610    dispatch_state: &WsDispatchState,
3611) -> Option<OrderContext> {
3612    // A submitted order has no venue order ID until its acceptance arrives
3613    let is_tracked_leg = match venue_order_id {
3614        Some(_) => order.is_open() && order.venue_order_ids().len() == 1,
3615        None => order.status() == OrderStatus::Submitted && order.venue_order_ids().is_empty(),
3616    };
3617
3618    if order.order_type() != OrderType::Limit
3619        || order.is_quote_quantity()
3620        || order.is_reduce_only()
3621        || order.is_contingency()
3622        || order.linked_order_ids().is_some()
3623        || order.parent_order_id().is_some()
3624        || !is_tracked_leg
3625        || order.is_pending_update()
3626        || !order.filled_qty().is_zero()
3627        || !order.trade_ids().is_empty()
3628        || order.venue_order_id() != venue_order_id
3629        || order
3630            .events()
3631            .iter()
3632            .any(|event| matches!(event, OrderEventAny::Updated(_)))
3633    {
3634        return None;
3635    }
3636
3637    let client_order_id = order.client_order_id();
3638    let context = OrderContext::from(order);
3639    if dispatch_state.lookup_context(&client_order_id) != Some(context)
3640        || dispatch_state.cached_venue_order_id(&client_order_id) != venue_order_id
3641        || dispatch_state.has_pending_modify(&client_order_id)
3642    {
3643        return None;
3644    }
3645
3646    Some(context)
3647}
3648
3649async fn recover_query_order_fills(
3650    http_client: &HyperliquidHttpClient,
3651    account_address: &str,
3652    report: &OrderStatusReport,
3653    context: &OrderContext,
3654    venue_order_id: Option<VenueOrderId>,
3655    dispatch_state: &WsDispatchState,
3656    emitter: &ExecutionEventEmitter,
3657) {
3658    let client_order_id = context.identity.client_order_id;
3659    let cloid = http_client
3660        .cached_client_order_id_cloid(&client_order_id)
3661        .unwrap_or_else(|| Cloid::from_client_order_id(client_order_id));
3662    let cloid_hex = cloid.to_hex();
3663
3664    if report.order_status != OrderStatus::Filled
3665        || report.reduce_only
3666        || report.order_type != OrderType::Limit
3667        || report.instrument_id != context.identity.instrument_id
3668        || report.order_side != Some(context.identity.order_side)
3669        || report.quantity != context.quantity
3670        || report.filled_qty != context.quantity
3671        || report
3672            .client_order_id
3673            .is_some_and(|id| id != client_order_id && id.as_str() != cloid_hex)
3674        || is_binding_changed(dispatch_state, &client_order_id, venue_order_id, report)
3675    {
3676        return;
3677    }
3678
3679    let fills =
3680        match collect_query_order_fills(http_client, account_address, report, context, cloid).await
3681        {
3682            Ok(fills) => fills,
3683            Err(e) => {
3684                log::warn!("Failed to recover fills for {client_order_id}: {e:#}");
3685                return;
3686            }
3687        };
3688
3689    // Admission does not own a leg across HTTP awaits; only unchanged bindings may recover
3690    if dispatch_state.lookup_context(&client_order_id) != Some(*context)
3691        || is_binding_changed(dispatch_state, &client_order_id, venue_order_id, report)
3692        || dispatch_state.has_pending_modify(&client_order_id)
3693    {
3694        log::warn!(
3695            "Discarding query fill recovery for {client_order_id}: order binding or terms changed"
3696        );
3697        return;
3698    }
3699
3700    for fill in fills {
3701        emitter.send_fill_report(fill);
3702    }
3703}
3704
3705// Only a query that started without a venue order ID may still be unbound
3706fn is_binding_changed(
3707    dispatch_state: &WsDispatchState,
3708    client_order_id: &ClientOrderId,
3709    venue_order_id: Option<VenueOrderId>,
3710    report: &OrderStatusReport,
3711) -> bool {
3712    match dispatch_state.cached_venue_order_id(client_order_id) {
3713        Some(bound) => bound != report.venue_order_id,
3714        None => venue_order_id.is_some(),
3715    }
3716}
3717
3718async fn collect_query_order_fills(
3719    http_client: &HyperliquidHttpClient,
3720    account_address: &str,
3721    report: &OrderStatusReport,
3722    context: &OrderContext,
3723    cloid: Cloid,
3724) -> anyhow::Result<Vec<FillReport>> {
3725    if http_client.get_account_address()? != account_address {
3726        anyhow::bail!("fill history account does not match the execution account");
3727    }
3728
3729    let mut fills = http_client.info_user_fills(account_address).await?;
3730    fills.retain(|fill| http_client.allows_venue_coin(&fill.coin));
3731    let oid = report.venue_order_id.as_str().parse::<u64>()?;
3732
3733    if let Some(fill) = fills
3734        .iter()
3735        .find(|fill| fill.time.checked_mul(1_000_000).is_none())
3736    {
3737        anyhow::bail!("invalid fill timestamp for venue order {}", fill.oid);
3738    }
3739
3740    for fill in fills.iter().filter(|fill| fill.oid == oid) {
3741        let fill_cloid = fill
3742            .cloid
3743            .as_deref()
3744            .map(Cloid::from_hex)
3745            .transpose()
3746            .map_err(anyhow::Error::msg)?;
3747
3748        if fill_cloid.is_some_and(|value| value != cloid)
3749            || fill.sz <= Decimal::ZERO
3750            || fill.px <= Decimal::ZERO
3751        {
3752            anyhow::bail!("invalid fill CLOID, quantity, or price for venue order {oid}");
3753        }
3754    }
3755
3756    let mut sweep = http_client.fill_reports_from_response(fills.clone(), None)?;
3757
3758    if !sweep.complete {
3759        anyhow::bail!("fill history could not be fully resolved or parsed");
3760    }
3761
3762    for (raw, parsed) in fills.iter().zip(&mut sweep.reports) {
3763        if raw.oid != oid {
3764            continue;
3765        }
3766
3767        if raw.sz != parsed.last_qty.as_decimal()
3768            || raw.px != parsed.last_px.as_decimal()
3769            || raw.fee != parsed.commission.as_decimal()
3770        {
3771            anyhow::bail!(
3772                "fill quantity, price, or commission loses precision for venue order {oid}"
3773            );
3774        }
3775
3776        parsed.client_order_id = Some(context.identity.client_order_id);
3777    }
3778
3779    validate_query_order_fills(sweep.reports, report, context)
3780}
3781
3782fn validate_query_order_fills(
3783    fills: Vec<FillReport>,
3784    report: &OrderStatusReport,
3785    context: &OrderContext,
3786) -> anyhow::Result<Vec<FillReport>> {
3787    let venue_order_id = report.venue_order_id;
3788    let client_order_id = context.identity.client_order_id;
3789    let mut unique: AHashMap<_, FillReport> = AHashMap::new();
3790    let mut filled_qty = Decimal::ZERO;
3791
3792    for mut fill in fills {
3793        if fill.venue_order_id != venue_order_id {
3794            continue;
3795        }
3796
3797        if fill.account_id != report.account_id
3798            || fill.instrument_id != report.instrument_id
3799            || fill.order_side != context.identity.order_side
3800            || fill.client_order_id.is_some_and(|id| id != client_order_id)
3801            || fill.last_qty.is_zero()
3802        {
3803            anyhow::bail!("fill identity or quantity mismatch for venue order {venue_order_id}");
3804        }
3805
3806        fill.client_order_id = Some(client_order_id);
3807        if let Some(previous) = unique.get(&fill.trade_id) {
3808            fill.report_id = previous.report_id;
3809            fill.ts_init = previous.ts_init;
3810            if fill != *previous {
3811                anyhow::bail!(
3812                    "conflicting duplicate trade {} for venue order {venue_order_id}",
3813                    fill.trade_id
3814                );
3815            }
3816
3817            continue;
3818        }
3819
3820        filled_qty += fill.last_qty.as_decimal();
3821        unique.insert(fill.trade_id, fill);
3822    }
3823
3824    if filled_qty != report.filled_qty.as_decimal() || filled_qty != context.quantity.as_decimal() {
3825        anyhow::bail!(
3826            "incomplete fills for venue order {venue_order_id}: expected {}, recovered {filled_qty}",
3827            context.quantity,
3828        );
3829    }
3830
3831    let mut fills: Vec<_> = unique.into_values().collect();
3832    fills.sort_by_key(|fill| (fill.ts_event, fill.trade_id));
3833    Ok(fills)
3834}
3835
3836fn attach_known_client_order_id(report: &mut OrderStatusReport, client_order_id: ClientOrderId) {
3837    if report.client_order_id.is_none() {
3838        report.client_order_id = Some(client_order_id);
3839    }
3840}
3841
3842// During a tracked cancel-replace the cached venue_order_id is still the old
3843// leg, so only its `Canceled` must be dropped (it would wrongly terminate the
3844// live order); a late `Filled` or any other status is forwarded for recovery.
3845fn is_inflight_modify_old_leg_cancel(
3846    dispatch_state: &WsDispatchState,
3847    client_order_id: &ClientOrderId,
3848    report: &OrderStatusReport,
3849) -> bool {
3850    report.order_status == OrderStatus::Canceled
3851        && dispatch_state.pending_modify_contains_old(client_order_id, report.venue_order_id)
3852}
3853
3854fn remove_generated_modify_cloid(
3855    http_client: &HyperliquidHttpClient,
3856    ws_client: &HyperliquidWebSocketClient,
3857    generated_modify_cloid: Option<(ClientOrderId, Cloid)>,
3858) {
3859    let Some((client_order_id, cloid)) = generated_modify_cloid else {
3860        return;
3861    };
3862
3863    if http_client.cached_client_order_id_cloid(&client_order_id) != Some(cloid) {
3864        return;
3865    }
3866
3867    let cloid_hex = Ustr::from(&cloid.to_hex());
3868    ws_client.remove_cloid_mapping(&cloid_hex);
3869    http_client.remove_client_order_id_cloid(&client_order_id);
3870}
3871
3872#[derive(Clone)]
3873struct CancelEntry {
3874    command_id: UUID4,
3875    strategy_id: StrategyId,
3876    instrument_id: InstrumentId,
3877    client_order_id: ClientOrderId,
3878    venue_order_id: Option<VenueOrderId>,
3879    symbol: Ustr,
3880    fast: bool,
3881}
3882
3883struct CancelDispatch {
3884    cloid_requests: Vec<(HyperliquidExchangeCancelByCloidRequest, CancelEntry)>,
3885    oid_requests: Vec<(HyperliquidExchangeCancelOrderRequest, CancelEntry)>,
3886}
3887
3888impl CancelDispatch {
3889    fn new() -> Self {
3890        Self {
3891            cloid_requests: Vec::new(),
3892            oid_requests: Vec::new(),
3893        }
3894    }
3895
3896    fn is_empty(&self) -> bool {
3897        self.cloid_requests.is_empty() && self.oid_requests.is_empty()
3898    }
3899
3900    fn push(
3901        &mut self,
3902        entry: &CancelEntry,
3903        asset: u32,
3904        http_client: &HyperliquidHttpClient,
3905    ) -> Result<(), CommandFailure> {
3906        if let Some(cloid) = http_client.cached_client_order_id_cloid(&entry.client_order_id) {
3907            self.cloid_requests.push((
3908                HyperliquidExchangeCancelByCloidRequest { asset, cloid },
3909                entry.clone(),
3910            ));
3911        } else if let Some(venue_order_id) = entry.venue_order_id {
3912            match venue_order_id.as_str().parse::<u64>() {
3913                Ok(oid) => {
3914                    self.oid_requests.push((
3915                        HyperliquidExchangeCancelOrderRequest { asset, oid },
3916                        entry.clone(),
3917                    ));
3918                }
3919                Err(_) => {
3920                    return Err(CommandFailure::not_sent("Invalid venue order ID format"));
3921                }
3922            }
3923        } else {
3924            let cloid = http_client.get_or_generate_client_order_id_cloid(entry.client_order_id);
3925            self.cloid_requests.push((
3926                HyperliquidExchangeCancelByCloidRequest { asset, cloid },
3927                entry.clone(),
3928            ));
3929        }
3930        Ok(())
3931    }
3932}
3933
3934fn classify_post_failure(failure: PostRequestError) -> CommandFailure {
3935    let (error, outcome) = match failure {
3936        PostRequestError::BeforeDispatch(error) => {
3937            let outcome = CommandFailure::not_sent(error.to_string());
3938            (error, outcome)
3939        }
3940        PostRequestError::AfterDispatch(error) => {
3941            let outcome = CommandFailure::ambiguous(error.to_string());
3942            (error, outcome)
3943        }
3944        PostRequestError::Rejected { error, reason } => {
3945            (error, CommandFailure::venue_rejected(reason))
3946        }
3947    };
3948
3949    log::debug!("WebSocket command failed: {error}");
3950    outcome
3951}
3952
3953fn emit_modify_failure(
3954    emitter: &ExecutionEventEmitter,
3955    command: &ModifyOrder,
3956    venue_order_id: Option<VenueOrderId>,
3957    failure: CommandFailure,
3958    ts_event: UnixNanos,
3959) {
3960    match failure {
3961        CommandFailure::NotSent(reason) => {
3962            emitter.emit_order_modify_denied_event(
3963                command.strategy_id,
3964                command.instrument_id,
3965                command.client_order_id,
3966                venue_order_id,
3967                &reason,
3968                ts_event,
3969                Some(command.command_id),
3970            );
3971        }
3972        CommandFailure::VenueRejected(reason) => {
3973            emitter.emit_order_modify_rejected_event(
3974                command.strategy_id,
3975                command.instrument_id,
3976                command.client_order_id,
3977                venue_order_id,
3978                &reason,
3979                ts_event,
3980                Some(command.command_id),
3981            );
3982        }
3983        CommandFailure::Ambiguous(reason) => {
3984            log::warn!(
3985                "Modify outcome unknown for {}: {reason}; awaiting reconciliation",
3986                command.client_order_id
3987            );
3988        }
3989    }
3990}
3991
3992fn emit_cancel_failure(
3993    emitter: &ExecutionEventEmitter,
3994    entry: &CancelEntry,
3995    failure: CommandFailure,
3996    ts_event: UnixNanos,
3997) {
3998    match failure {
3999        CommandFailure::NotSent(reason) => {
4000            emitter.emit_order_cancel_denied_event(
4001                entry.strategy_id,
4002                entry.instrument_id,
4003                entry.client_order_id,
4004                entry.venue_order_id,
4005                &reason,
4006                ts_event,
4007                Some(entry.command_id),
4008            );
4009        }
4010        CommandFailure::VenueRejected(reason) => {
4011            emitter.emit_order_cancel_rejected_event(
4012                entry.strategy_id,
4013                entry.instrument_id,
4014                entry.client_order_id,
4015                entry.venue_order_id,
4016                &reason,
4017                ts_event,
4018                Some(entry.command_id),
4019            );
4020        }
4021        CommandFailure::Ambiguous(reason) => {
4022            log::warn!(
4023                "Cancel outcome unknown for {}: {reason}; awaiting reconciliation",
4024                entry.client_order_id
4025            );
4026        }
4027    }
4028}
4029
4030async fn submit_cancel_dispatch(
4031    label: &str,
4032    dispatch: CancelDispatch,
4033    ws_client: &HyperliquidWebSocketClient,
4034    http_client: &HyperliquidHttpClient,
4035    emitter: &ExecutionEventEmitter,
4036    clock: &'static AtomicTime,
4037) {
4038    let CancelDispatch {
4039        cloid_requests,
4040        oid_requests,
4041    } = dispatch;
4042
4043    let (fast_cloid_requests, fast_cloid_entries, cloid_requests, cloid_entries) =
4044        split_fast_cancel_requests(cloid_requests);
4045
4046    if !fast_cloid_requests.is_empty() {
4047        let action = HyperliquidExchangeAction::CancelByCloid {
4048            cancels: fast_cloid_requests,
4049            fast: Some(true),
4050        };
4051        submit_cancel_action(
4052            label,
4053            action,
4054            &fast_cloid_entries,
4055            ws_client,
4056            http_client,
4057            emitter,
4058            clock,
4059        )
4060        .await;
4061    }
4062
4063    if !cloid_requests.is_empty() {
4064        let action = HyperliquidExchangeAction::CancelByCloid {
4065            cancels: cloid_requests,
4066            fast: None,
4067        };
4068        submit_cancel_action(
4069            label,
4070            action,
4071            &cloid_entries,
4072            ws_client,
4073            http_client,
4074            emitter,
4075            clock,
4076        )
4077        .await;
4078    }
4079
4080    let (fast_oid_requests, fast_oid_entries, oid_requests, oid_entries) =
4081        split_fast_cancel_requests(oid_requests);
4082
4083    if !fast_oid_requests.is_empty() {
4084        let action = HyperliquidExchangeAction::Cancel {
4085            cancels: fast_oid_requests,
4086            fast: Some(true),
4087        };
4088        submit_cancel_action(
4089            label,
4090            action,
4091            &fast_oid_entries,
4092            ws_client,
4093            http_client,
4094            emitter,
4095            clock,
4096        )
4097        .await;
4098    }
4099
4100    if !oid_requests.is_empty() {
4101        let action = HyperliquidExchangeAction::Cancel {
4102            cancels: oid_requests,
4103            fast: None,
4104        };
4105        submit_cancel_action(
4106            label,
4107            action,
4108            &oid_entries,
4109            ws_client,
4110            http_client,
4111            emitter,
4112            clock,
4113        )
4114        .await;
4115    }
4116}
4117
4118fn split_fast_cancel_requests<T>(
4119    requests: Vec<(T, CancelEntry)>,
4120) -> (Vec<T>, Vec<CancelEntry>, Vec<T>, Vec<CancelEntry>) {
4121    let mut fast_requests = Vec::new();
4122    let mut fast_entries = Vec::new();
4123    let mut requests_without_fast = Vec::new();
4124    let mut entries_without_fast = Vec::new();
4125
4126    for (request, entry) in requests {
4127        if entry.fast {
4128            fast_requests.push(request);
4129            fast_entries.push(entry);
4130        } else {
4131            requests_without_fast.push(request);
4132            entries_without_fast.push(entry);
4133        }
4134    }
4135
4136    (
4137        fast_requests,
4138        fast_entries,
4139        requests_without_fast,
4140        entries_without_fast,
4141    )
4142}
4143
4144async fn submit_cancel_action(
4145    label: &str,
4146    action: HyperliquidExchangeAction,
4147    sent_entries: &[CancelEntry],
4148    ws_client: &HyperliquidWebSocketClient,
4149    http_client: &HyperliquidHttpClient,
4150    emitter: &ExecutionEventEmitter,
4151    clock: &'static AtomicTime,
4152) {
4153    match ws_client
4154        .post_action_command(http_client, &action)
4155        .await
4156        .map_err(classify_post_failure)
4157    {
4158        Ok(response) => {
4159            let inner_errors = extract_inner_errors(&response);
4160            let ts = clock.get_time_ns();
4161
4162            if inner_errors.is_empty() {
4163                log::debug!("{label} submitted successfully: {response:?}");
4164            } else if let Some(reason) =
4165                cancel_status_count_mismatch_reason(label, sent_entries.len(), inner_errors.len())
4166            {
4167                log::warn!("{reason}");
4168            } else {
4169                for (entry, error) in sent_entries.iter().zip(inner_errors) {
4170                    if let Some(reason) = error {
4171                        emit_cancel_failure(
4172                            emitter,
4173                            entry,
4174                            CommandFailure::venue_rejected(reason),
4175                            ts,
4176                        );
4177                    }
4178                }
4179            }
4180        }
4181        Err(failure) => {
4182            for entry in sent_entries {
4183                emit_cancel_failure(emitter, entry, failure.clone(), clock.get_time_ns());
4184            }
4185        }
4186    }
4187}
4188
4189/// Registers an order's context in the dispatch state so its subsequent
4190/// WebSocket lifecycle can route through the typed-event path.
4191///
4192/// Quote-quantity orders submit a quote amount (e.g. 100 USD) but the venue
4193/// reports fills in base units. Comparing those two when deciding whether an
4194/// order is fully filled would leave the order stuck "open" forever, so they
4195/// flow through the untracked path and the engine reconciles them from
4196/// status reports instead.
4197fn register_order_context_into(state: &WsDispatchState, order: &OrderAny) {
4198    let context = OrderContext::from(order);
4199    if context.is_quote_quantity {
4200        return;
4201    }
4202
4203    state.register_context(context);
4204    state.mark_submission_pending(context.identity.client_order_id);
4205}
4206
4207fn order_normal_tpsl_submission(
4208    orders: Vec<OrderAny>,
4209    requests: Vec<HyperliquidExchangePlaceOrderRequest>,
4210    grouping: HyperliquidExchangeGrouping,
4211) -> (Vec<OrderAny>, Vec<HyperliquidExchangePlaceOrderRequest>) {
4212    if grouping != HyperliquidExchangeGrouping::NormalTpsl {
4213        return (orders, requests);
4214    }
4215
4216    let mut pairs: Vec<_> = orders.into_iter().zip(requests).collect();
4217    pairs.sort_by_key(|(order, request)| {
4218        if !order.is_reduce_only() {
4219            0
4220        } else if matches!(
4221            &request.kind,
4222            HyperliquidExchangeOrderKind::Trigger { trigger }
4223                if trigger.tpsl == HyperliquidExchangeTpSl::Sl
4224        ) {
4225            2
4226        } else {
4227            1
4228        }
4229    });
4230
4231    pairs.into_iter().unzip()
4232}
4233
4234/// Validates that an order is acceptable for submission to Hyperliquid.
4235///
4236/// Checks symbol format, order type support, and HIP-4-specific restrictions
4237/// (no reduce-only, no trigger order types on outcome side tokens).
4238///
4239/// # Errors
4240///
4241/// Returns an error if validation fails. The error describes the first failure encountered.
4242pub fn validate_order_for_hyperliquid(order: &OrderAny) -> anyhow::Result<()> {
4243    let instrument_id = order.instrument_id();
4244    let symbol = instrument_id.symbol.as_str();
4245    let product_type = HyperliquidProductType::from_symbol(symbol).map_err(|_| {
4246        anyhow::anyhow!(
4247            "Unsupported instrument symbol format for Hyperliquid: {symbol} \
4248             (expected -PERP, -SPOT, or HIP-4 outcome `{{N}}-{{YES|NO}}-OUTCOME`)"
4249        )
4250    })?;
4251
4252    match order.order_type() {
4253        OrderType::Market
4254        | OrderType::Limit
4255        | OrderType::StopMarket
4256        | OrderType::StopLimit
4257        | OrderType::MarketIfTouched
4258        | OrderType::LimitIfTouched => {}
4259        _ => anyhow::bail!(
4260            "Unsupported order type for Hyperliquid: {:?}",
4261            order.order_type()
4262        ),
4263    }
4264
4265    // HIP-4 outcomes are fully-collateralized side tokens with no margin,
4266    // funding, or trigger machinery. Reject features that don't apply.
4267    if product_type == HyperliquidProductType::Outcome {
4268        if order.is_reduce_only() {
4269            anyhow::bail!("Reduce-only is not supported for Hyperliquid HIP-4 outcomes: {symbol}");
4270        }
4271
4272        if !matches!(order.order_type(), OrderType::Market | OrderType::Limit) {
4273            anyhow::bail!(
4274                "Trigger order types are not supported for Hyperliquid HIP-4 outcomes: \
4275                 {symbol} (received {:?})",
4276                order.order_type()
4277            );
4278        }
4279    }
4280
4281    if matches!(
4282        order.order_type(),
4283        OrderType::StopMarket
4284            | OrderType::StopLimit
4285            | OrderType::MarketIfTouched
4286            | OrderType::LimitIfTouched
4287    ) && order.trigger_price().is_none()
4288    {
4289        anyhow::bail!(
4290            "Conditional orders require a trigger price for Hyperliquid: {:?}",
4291            order.order_type()
4292        );
4293    }
4294
4295    if matches!(
4296        order.order_type(),
4297        OrderType::Limit | OrderType::StopLimit | OrderType::LimitIfTouched
4298    ) && order.price().is_none()
4299    {
4300        anyhow::bail!(
4301            "Limit orders require a limit price for Hyperliquid: {:?}",
4302            order.order_type()
4303        );
4304    }
4305
4306    Ok(())
4307}
4308
4309fn can_fast_cancel_order(order_type: Option<OrderType>) -> bool {
4310    matches!(order_type, Some(OrderType::Market | OrderType::Limit))
4311}
4312
4313fn cancel_status_count_mismatch_reason(
4314    label: &str,
4315    expected_count: usize,
4316    actual_count: usize,
4317) -> Option<String> {
4318    (actual_count != 0 && actual_count != expected_count).then(|| {
4319        format!(
4320            "{label} response status count mismatch: expected {expected_count}, received {actual_count}"
4321        )
4322    })
4323}
4324
4325#[expect(clippy::too_many_arguments)]
4326async fn post_order_batch(
4327    label: &str,
4328    orders: Vec<OrderAny>,
4329    requests: Vec<HyperliquidExchangePlaceOrderRequest>,
4330    grouping: HyperliquidExchangeGrouping,
4331    builder: Option<crate::http::models::HyperliquidExchangeBuilderFee>,
4332    emitter: &ExecutionEventEmitter,
4333    ws_client: &HyperliquidWebSocketClient,
4334    http_client: &HyperliquidHttpClient,
4335    dispatch_state: Arc<WsDispatchState>,
4336    staged_brackets: Arc<Mutex<StagedBracketState>>,
4337    clock: &'static AtomicTime,
4338    task_spawner: TaskSpawner,
4339) {
4340    let cloid_hexes: Vec<Ustr> = requests
4341        .iter()
4342        .map(|request| {
4343            Ustr::from(
4344                &request
4345                    .cloid
4346                    .expect("order conversion must set a CLOID")
4347                    .to_hex(),
4348            )
4349        })
4350        .collect();
4351    let action = HyperliquidExchangeAction::Order {
4352        orders: requests,
4353        grouping,
4354        builder,
4355    };
4356    let rejection_route = PostRejectionRoute::with_staged_brackets(
4357        emitter,
4358        ws_client,
4359        http_client,
4360        dispatch_state,
4361        staged_brackets,
4362        task_spawner,
4363    );
4364
4365    match ws_client
4366        .post_action_command(http_client, &action)
4367        .await
4368        .map_err(classify_post_failure)
4369    {
4370        Ok(response) => {
4371            let inner_errors = extract_inner_errors(&response);
4372            let ts = clock.get_time_ns();
4373
4374            if inner_errors.len() == orders.len() {
4375                for ((order, cloid_hex), error) in orders
4376                    .iter()
4377                    .zip(cloid_hexes.iter())
4378                    .zip(inner_errors.iter())
4379                {
4380                    if let Some(error_msg) = error {
4381                        log::debug!(
4382                            "Order {} rejected by exchange: {error_msg}",
4383                            order.client_order_id(),
4384                        );
4385                        rejection_route.emit_once(order, error_msg, ts, cloid_hex);
4386                    }
4387                }
4388            } else if orders.len() > 1
4389                && inner_errors.len() == 1
4390                && let Some(error_msg) = inner_errors[0].as_ref()
4391            {
4392                log::debug!(
4393                    "{label} rejected by deterministic whole-batch validation: {error_msg}",
4394                );
4395
4396                for (order, cloid_hex) in orders.iter().zip(cloid_hexes.iter()) {
4397                    rejection_route.emit_once(order, error_msg, ts, cloid_hex);
4398                }
4399            } else if !inner_errors.is_empty() {
4400                log::warn!(
4401                    "{label} returned {} statuses for {} orders; preserving unresolved identities \
4402                     for WebSocket or startup reconciliation",
4403                    inner_errors.len(),
4404                    orders.len(),
4405                );
4406            } else {
4407                log::debug!("{label} submitted successfully: {response:?}");
4408            }
4409        }
4410        Err(CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason)) => {
4411            let ts = clock.get_time_ns();
4412            for (order, cloid_hex) in orders.iter().zip(&cloid_hexes) {
4413                rejection_route.emit_once(order, &reason, ts, cloid_hex);
4414            }
4415        }
4416        Err(CommandFailure::Ambiguous(reason)) => {
4417            log::warn!("{label} outcome unknown: {reason}; awaiting reconciliation");
4418        }
4419    }
4420
4421    let ts = clock.get_time_ns();
4422    for (order, cloid_hex) in orders.iter().zip(cloid_hexes.iter()) {
4423        rejection_route.resolve_without_post_rejection(order, ts, cloid_hex);
4424    }
4425}
4426
4427#[expect(clippy::too_many_arguments)]
4428fn spawn_staged_children(
4429    children: Vec<StagedBracketChild>,
4430    emitter: &ExecutionEventEmitter,
4431    ws_client: &HyperliquidWebSocketClient,
4432    http_client: &HyperliquidHttpClient,
4433    dispatch_state: Arc<WsDispatchState>,
4434    staged_brackets: Arc<Mutex<StagedBracketState>>,
4435    builder: Option<crate::http::models::HyperliquidExchangeBuilderFee>,
4436    clock: &'static AtomicTime,
4437    task_spawner: &TaskSpawner,
4438) {
4439    let (orders, requests): (Vec<_>, Vec<_>) = children
4440        .into_iter()
4441        .map(|child| (child.order, child.request))
4442        .unzip();
4443
4444    let denied_orders = orders.clone();
4445    let task_emitter = emitter.clone();
4446    let ws_client = ws_client.clone();
4447    let http_client = http_client.clone();
4448    let child_spawner = task_spawner.clone();
4449
4450    if let Err(e) = task_spawner.spawn(async move {
4451        for (order, request) in orders.iter().zip(requests.iter()) {
4452            let cloid = request.cloid.expect("order conversion must set a CLOID");
4453            http_client.cache_client_order_id_cloid(order.client_order_id(), cloid);
4454            ws_client.cache_cloid_mapping(Ustr::from(&cloid.to_hex()), order.client_order_id());
4455            register_order_context_into(&dispatch_state, order);
4456            task_emitter.emit_order_submitted(order);
4457        }
4458
4459        post_order_batch(
4460            "Bracket child batch",
4461            orders,
4462            requests,
4463            HyperliquidExchangeGrouping::Na,
4464            builder,
4465            &task_emitter,
4466            &ws_client,
4467            &http_client,
4468            dispatch_state,
4469            staged_brackets,
4470            clock,
4471            child_spawner,
4472        )
4473        .await;
4474    }) {
4475        log::warn!("Skipping Hyperliquid bracket child batch after shutdown began: {e}");
4476
4477        for order in &denied_orders {
4478            emitter.emit_order_denied(
4479                order,
4480                &OrderDeniedReason::SubmitFailed {
4481                    detail: TASK_SHUTDOWN_DENIAL_REASON.to_string(),
4482                }
4483                .to_string(),
4484            );
4485        }
4486    }
4487}
4488
4489fn spawn_active_sibling_cancel(
4490    sibling: StagedBracketChild,
4491    emitter: &ExecutionEventEmitter,
4492    ws_client: &HyperliquidWebSocketClient,
4493    http_client: &HyperliquidHttpClient,
4494    dispatch_state: &WsDispatchState,
4495    task_spawner: &TaskSpawner,
4496) {
4497    let client_order_id = sibling.order.client_order_id();
4498    let Some(cloid) = sibling.request.cloid else {
4499        log::error!("Cannot cancel OUO sibling {client_order_id}: missing CLOID");
4500        return;
4501    };
4502    let venue_order_id = dispatch_state.cached_venue_order_id(&client_order_id);
4503    let action = HyperliquidExchangeAction::CancelByCloid {
4504        cancels: vec![HyperliquidExchangeCancelByCloidRequest {
4505            asset: sibling.request.asset,
4506            cloid,
4507        }],
4508        fast: can_fast_cancel_order(Some(sibling.order.order_type())).then_some(true),
4509    };
4510    let emitter = emitter.clone();
4511    let ws_client = ws_client.clone();
4512    let http_client = http_client.clone();
4513
4514    if let Err(e) = task_spawner.spawn(async move {
4515        match ws_client.post_action_exec(&http_client, &action).await {
4516            Ok(response) if response.is_ok() => {
4517                if let Some(error) = extract_inner_error(&response) {
4518                    emitter.emit_order_cancel_rejected(
4519                        &sibling.order,
4520                        venue_order_id,
4521                        &error,
4522                        get_atomic_clock_realtime().get_time_ns(),
4523                        None,
4524                    );
4525                }
4526            }
4527            Ok(response) => {
4528                log::warn!(
4529                    "OUO sibling cancel for {client_order_id} returned an ambiguous response; \
4530                     awaiting WebSocket or startup reconciliation: {}",
4531                    extract_error_message(&response),
4532                );
4533            }
4534            Err(e) => {
4535                log::warn!(
4536                    "OUO sibling cancel for {client_order_id} failed; awaiting WebSocket or \
4537                     startup reconciliation: {e}",
4538                );
4539            }
4540        }
4541    }) {
4542        log::warn!("Skipping Hyperliquid sibling cancellation after shutdown began: {e}");
4543    }
4544}
4545
4546fn spawn_active_sibling_resize(
4547    sibling: StagedBracketChild,
4548    target_total_qty: Quantity,
4549    emitter: &ExecutionEventEmitter,
4550    ws_client: &HyperliquidWebSocketClient,
4551    http_client: &HyperliquidHttpClient,
4552    dispatch_state: &Arc<WsDispatchState>,
4553    task_spawner: &TaskSpawner,
4554) {
4555    let client_order_id = sibling.order.client_order_id();
4556    let Some(old_venue_order_id) = dispatch_state.cached_venue_order_id(&client_order_id) else {
4557        log::warn!(
4558            "Cannot resize OUO sibling {client_order_id}: venue order ID not known; awaiting \
4559             WebSocket or startup reconciliation",
4560        );
4561        return;
4562    };
4563    let filled_qty = dispatch_state
4564        .previous_filled_qty(&client_order_id)
4565        .unwrap_or_else(|| Quantity::zero(target_total_qty.precision));
4566    let Some(order) = build_ouo_resize_request(&sibling, target_total_qty, filled_qty) else {
4567        spawn_active_sibling_cancel(
4568            sibling,
4569            emitter,
4570            ws_client,
4571            http_client,
4572            dispatch_state,
4573            task_spawner,
4574        );
4575        return;
4576    };
4577    let Some(cloid) = order.cloid else {
4578        log::error!("Cannot resize OUO sibling {client_order_id}: missing CLOID");
4579        return;
4580    };
4581
4582    let generation =
4583        dispatch_state.mark_pending_modify(client_order_id, old_venue_order_id, target_total_qty);
4584    dispatch_state.stash_modify_request(client_order_id, order.clone());
4585    let action = HyperliquidExchangeAction::Modify {
4586        modify: HyperliquidExchangeModifyOrderRequest {
4587            oid: HyperliquidExchangeModifyTarget::Cloid(cloid),
4588            order,
4589        },
4590    };
4591    let ws_client = ws_client.clone();
4592    let http_client = http_client.clone();
4593    let dispatch_state = dispatch_state.clone();
4594
4595    if let Err(e) = task_spawner.spawn(async move {
4596        match ws_client.post_action_exec(&http_client, &action).await {
4597            Ok(response) if response.is_ok() && extract_inner_error(&response).is_none() => {
4598                log::debug!("OUO sibling resize submitted for {client_order_id}");
4599            }
4600            Ok(response) => {
4601                dispatch_state.clear_modify_generation(&client_order_id, generation);
4602                log::warn!(
4603                    "OUO sibling resize for {client_order_id} rejected: {}",
4604                    extract_inner_error(&response)
4605                        .unwrap_or_else(|| extract_error_message(&response)),
4606                );
4607            }
4608            Err(e) if e.is_transport_error() => {
4609                log::warn!(
4610                    "OUO sibling resize transport failure for {client_order_id}: {e}; awaiting \
4611                     WebSocket or startup reconciliation",
4612                );
4613            }
4614            Err(e) => {
4615                dispatch_state.clear_modify_generation(&client_order_id, generation);
4616                log::warn!("OUO sibling resize failed for {client_order_id}: {e}");
4617            }
4618        }
4619    }) {
4620        log::warn!("Skipping Hyperliquid sibling resize after shutdown began: {e}");
4621    }
4622}
4623
4624fn build_ouo_resize_request(
4625    sibling: &StagedBracketChild,
4626    target_total_qty: Quantity,
4627    filled_qty: Quantity,
4628) -> Option<HyperliquidExchangePlaceOrderRequest> {
4629    if target_total_qty <= filled_qty {
4630        return None;
4631    }
4632
4633    let mut request = sibling.request.clone();
4634    request.size = (target_total_qty - filled_qty).as_decimal().normalize();
4635    Some(request)
4636}
4637
4638struct PostRejectionRoute {
4639    emitter: ExecutionEventEmitter,
4640    ws_client: HyperliquidWebSocketClient,
4641    http_client: HyperliquidHttpClient,
4642    dispatch_state: Arc<WsDispatchState>,
4643    staged_brackets: Arc<Mutex<StagedBracketState>>,
4644    task_spawner: TaskSpawner,
4645}
4646
4647impl PostRejectionRoute {
4648    fn new(
4649        emitter: &ExecutionEventEmitter,
4650        ws_client: &HyperliquidWebSocketClient,
4651        http_client: &HyperliquidHttpClient,
4652        dispatch_state: Arc<WsDispatchState>,
4653        task_spawner: TaskSpawner,
4654    ) -> Self {
4655        Self {
4656            emitter: emitter.clone(),
4657            ws_client: ws_client.clone(),
4658            http_client: http_client.clone(),
4659            dispatch_state,
4660            staged_brackets: Arc::new(Mutex::new(StagedBracketState::default())),
4661            task_spawner,
4662        }
4663    }
4664
4665    fn with_staged_brackets(
4666        emitter: &ExecutionEventEmitter,
4667        ws_client: &HyperliquidWebSocketClient,
4668        http_client: &HyperliquidHttpClient,
4669        dispatch_state: Arc<WsDispatchState>,
4670        staged_brackets: Arc<Mutex<StagedBracketState>>,
4671        task_spawner: TaskSpawner,
4672    ) -> Self {
4673        Self {
4674            emitter: emitter.clone(),
4675            ws_client: ws_client.clone(),
4676            http_client: http_client.clone(),
4677            dispatch_state,
4678            staged_brackets,
4679            task_spawner,
4680        }
4681    }
4682
4683    fn emit_once(
4684        &self,
4685        order: &OrderAny,
4686        reason: &str,
4687        ts_event: UnixNanos,
4688        cloid_hex: &Ustr,
4689    ) -> bool {
4690        let client_order_id = order.client_order_id();
4691        let rejection = self.dispatch_state.resolve_submission(&client_order_id);
4692        let has_fills = self
4693            .dispatch_state
4694            .previous_filled_qty(&client_order_id)
4695            .is_some_and(|qty| !qty.is_zero())
4696            || !order.filled_qty().is_zero();
4697
4698        if let Some(report) = rejection.filter(|report| !report.filled_qty.is_zero())
4699            && self
4700                .dispatch_state
4701                .lookup_context(&client_order_id)
4702                .is_some()
4703        {
4704            if dispatch_order_event(&report, &self.dispatch_state, &self.emitter, ts_event)
4705                == DispatchOutcome::Skip
4706            {
4707                return false;
4708            }
4709        } else if !self.dispatch_state.insert_filled(client_order_id) {
4710            log::debug!(
4711                "Skipping duplicate post rejection for terminal order {client_order_id}: {reason}",
4712            );
4713            self.ws_client.remove_cloid_mapping(cloid_hex);
4714            self.http_client
4715                .remove_client_order_id_cloid(&client_order_id);
4716            return false;
4717        } else if has_fills {
4718            self.emitter.emit_order_canceled(
4719                order,
4720                self.dispatch_state.cached_venue_order_id(&client_order_id),
4721                ts_event,
4722            );
4723        } else {
4724            if reason.contains(HYPERLIQUID_BUILDER_FEE_NOT_APPROVED) {
4725                log::warn!(
4726                    "Builder fee not approved: complete the one-time 0% builder approval \
4727                     (signed by the master wallet). See: {HYPERLIQUID_BUILDER_APPROVAL_DOCS_URL}",
4728                );
4729            }
4730
4731            let normalized_reason = reason.to_lowercase();
4732            let due_post_only = order.is_post_only()
4733                && (normalized_reason.contains(&HYPERLIQUID_POST_ONLY_WOULD_MATCH.to_lowercase())
4734                    || normalized_reason
4735                        .contains("post-only order would have immediately matched"));
4736            self.emitter
4737                .emit_order_rejected(order, reason, ts_event, due_post_only);
4738            let staged_children = self
4739                .staged_brackets
4740                .lock()
4741                .cancel_for_parent(&client_order_id);
4742
4743            for child in staged_children {
4744                self.emitter.emit_order_canceled(&child, None, ts_event);
4745            }
4746        }
4747
4748        let active_sibling = self
4749            .staged_brackets
4750            .lock()
4751            .take_active_sibling(&client_order_id);
4752
4753        if let Some(sibling) = active_sibling {
4754            spawn_active_sibling_cancel(
4755                sibling,
4756                &self.emitter,
4757                &self.ws_client,
4758                &self.http_client,
4759                &self.dispatch_state,
4760                &self.task_spawner,
4761            );
4762        }
4763
4764        self.dispatch_state.insert_terminal_cloid(*cloid_hex);
4765        self.dispatch_state.cleanup_terminal(&client_order_id);
4766        self.ws_client.remove_cloid_mapping(cloid_hex);
4767        self.http_client
4768            .remove_client_order_id_cloid(&client_order_id);
4769
4770        true
4771    }
4772
4773    fn resolve_without_post_rejection(
4774        &self,
4775        order: &OrderAny,
4776        ts_init: UnixNanos,
4777        cloid_hex: &Ustr,
4778    ) {
4779        let client_order_id = order.client_order_id();
4780        let Some(report) = self.dispatch_state.resolve_submission(&client_order_id) else {
4781            return;
4782        };
4783        let is_terminal = report.order_status.is_closed();
4784        let outcome = dispatch_order_event(&report, &self.dispatch_state, &self.emitter, ts_init);
4785
4786        if outcome == DispatchOutcome::External {
4787            self.emitter.send_order_status_report(report);
4788        }
4789
4790        if is_terminal && outcome != DispatchOutcome::Skip {
4791            if self.dispatch_state.filled_orders.contains(&client_order_id) {
4792                self.dispatch_state.insert_terminal_cloid(*cloid_hex);
4793            }
4794
4795            self.ws_client.remove_cloid_mapping(cloid_hex);
4796            self.http_client
4797                .remove_client_order_id_cloid(&client_order_id);
4798        }
4799    }
4800}
4801
4802/// Routes a single execution report through the two-tier dispatch.
4803///
4804/// For tracked orders this emits typed `OrderEventAny` events via the
4805/// dispatch module; external / untracked orders fall back to the raw report
4806/// so the engine can reconcile. Cloid-mapping cleanup is handled here so
4807/// long-running sessions do not leak mapping entries. Returns whether to suppress
4808/// bracket terminal handling, and any corrective reduce the dispatch queued.
4809fn handle_execution_report(
4810    report: ExecutionReport,
4811    dispatch_state: &WsDispatchState,
4812    emitter: &ExecutionEventEmitter,
4813    ws_client: &HyperliquidWebSocketClient,
4814    http_client: &HyperliquidHttpClient,
4815    pending_filled_cloids: &mut FifoCache<ClientOrderId, 10_000>,
4816    ts_init: UnixNanos,
4817) -> (bool, Option<(ClientOrderId, CorrectiveReduce)>) {
4818    match report {
4819        ExecutionReport::Order(order_report) => {
4820            let is_filled_marker = matches!(order_report.order_status, OrderStatus::Filled);
4821            let is_terminal = order_report.order_status.is_closed();
4822            let client_order_id = order_report.client_order_id;
4823
4824            let skip_terminal = match (order_report.order_status, order_report.filled_qty.is_zero())
4825            {
4826                (OrderStatus::Canceled, _) | (OrderStatus::Rejected, false) => true,
4827                (OrderStatus::Rejected, true) => {
4828                    !client_order_id.is_some_and(|id| dispatch_state.submission_pending(&id))
4829                }
4830                _ => false,
4831            };
4832
4833            let outcome = dispatch_order_event(&order_report, dispatch_state, emitter, ts_init);
4834
4835            if outcome == DispatchOutcome::External {
4836                emitter.send_order_status_report(order_report);
4837            }
4838
4839            // Cloid cleanup:
4840            //
4841            // * `Skip` (stale cancel leg of a cancel-replace, cancel-before-accept
4842            //   race, or replay after terminal): leave the mapping intact. The
4843            //   still-open replacement order depends on it for subsequent events,
4844            //   and a genuinely terminal replay had its mapping evicted earlier.
4845            // * `Tracked` + status-only FILLED marker: defer the eviction until
4846            //   the matching `FillReport` lands so the partial fill preceding it
4847            //   keeps its client-order-id link.
4848            // * `Tracked` non-marker terminal and `External` terminal: evict now
4849            //   so long-running sessions do not leak cloid mappings.
4850            if let Some(id) = client_order_id
4851                && is_terminal
4852            {
4853                match outcome {
4854                    DispatchOutcome::Skip => {}
4855                    DispatchOutcome::Tracked if is_filled_marker => {
4856                        pending_filled_cloids.add(id);
4857                    }
4858                    DispatchOutcome::Tracked | DispatchOutcome::External => {
4859                        remove_cloid_mapping_for_client_order_id(
4860                            ws_client,
4861                            http_client,
4862                            dispatch_state,
4863                            &id,
4864                        );
4865                    }
4866                }
4867            }
4868
4869            // Hand any queued corrective reduce to the loop to post; this
4870            // cache-free task cannot rebuild the order spec itself.
4871            let corrective = client_order_id.and_then(|id| {
4872                dispatch_state
4873                    .take_corrective(&id)
4874                    .map(|corrective| (id, corrective))
4875            });
4876
4877            (
4878                skip_terminal && outcome == DispatchOutcome::Skip,
4879                corrective,
4880            )
4881        }
4882        ExecutionReport::Fill(fill_report) => {
4883            let client_order_id = fill_report.client_order_id;
4884
4885            let outcome = dispatch_order_fill(&fill_report, dispatch_state, emitter, ts_init);
4886
4887            if outcome == DispatchOutcome::External {
4888                emitter.send_fill_report(fill_report);
4889            }
4890
4891            // Skip cleanup while a cancel-replace fill is buffered; the
4892            // replacement ACCEPTED still needs to resolve the cloid (GH-3972).
4893            if let Some(id) = client_order_id
4894                && pending_filled_cloids.contains(&id)
4895                && dispatch_state.buffered_fill_count(&id) == 0
4896            {
4897                pending_filled_cloids.remove(&id);
4898                remove_cloid_mapping_for_client_order_id(
4899                    ws_client,
4900                    http_client,
4901                    dispatch_state,
4902                    &id,
4903                );
4904            }
4905
4906            let corrective = client_order_id.and_then(|id| {
4907                dispatch_state
4908                    .take_corrective(&id)
4909                    .map(|corrective| (id, corrective))
4910            });
4911
4912            (false, corrective)
4913        }
4914    }
4915}
4916
4917/// Posts a corrective reduce queued by the cancel-replace promotion.
4918///
4919/// Runs on the runtime (not the WS receive loop) so the post does not block
4920/// event processing. Keeps the re-armed pending-modify marker only while the
4921/// reduce may still be live (a clean ack, or a transport failure the WS may
4922/// reconcile); clears it otherwise so a stale marker cannot hold a later real
4923/// `CANCELED(oid)` as a cancel-before-accept leg. Clears only the reduce's own
4924/// marker, so a modify of the order still in flight keeps its own.
4925fn spawn_corrective_reduce(
4926    ws_client: &HyperliquidWebSocketClient,
4927    http_client: &HyperliquidHttpClient,
4928    dispatch_state: &Arc<WsDispatchState>,
4929    client_order_id: ClientOrderId,
4930    corrective: CorrectiveReduce,
4931    task_spawner: &TaskSpawner,
4932) {
4933    let ws_client = ws_client.clone();
4934    let http_client = http_client.clone();
4935    let dispatch_state = dispatch_state.clone();
4936    let CorrectiveReduce {
4937        oid,
4938        generation,
4939        request,
4940    } = corrective;
4941
4942    if let Err(e) = task_spawner.spawn(async move {
4943        let action = HyperliquidExchangeAction::Modify {
4944            modify: HyperliquidExchangeModifyOrderRequest {
4945                oid: oid.into(),
4946                order: request,
4947            },
4948        };
4949
4950        let keep_marker = match ws_client.post_action_exec(&http_client, &action).await {
4951            Ok(resp) if resp.is_ok() && extract_inner_error(&resp).is_none() => {
4952                log::debug!("Corrective reduce acknowledged for {client_order_id} on oid {oid}");
4953                true
4954            }
4955            Ok(resp) => {
4956                let reason =
4957                    extract_inner_error(&resp).unwrap_or_else(|| extract_error_message(&resp));
4958                log::warn!(
4959                    "Corrective reduce rejected for {client_order_id} on oid {oid}: {reason}"
4960                );
4961                false
4962            }
4963            Err(e) if e.is_transport_error() => {
4964                log::warn!(
4965                    "Corrective reduce transport failure for {client_order_id} on oid {oid}: \
4966                     {e}; awaiting WS reconciliation",
4967                );
4968                true
4969            }
4970            Err(e) => {
4971                log::warn!("Corrective reduce failed for {client_order_id} on oid {oid}: {e}");
4972                false
4973            }
4974        };
4975
4976        if !keep_marker {
4977            dispatch_state.clear_modify_generation(&client_order_id, generation);
4978        }
4979    }) {
4980        log::warn!("Skipping Hyperliquid corrective reduce after shutdown began: {e}");
4981    }
4982}
4983
4984fn remove_cloid_mapping_for_client_order_id(
4985    ws_client: &HyperliquidWebSocketClient,
4986    http_client: &HyperliquidHttpClient,
4987    dispatch_state: &WsDispatchState,
4988    client_order_id: &ClientOrderId,
4989) {
4990    let terminal = dispatch_state.filled_orders.contains(client_order_id);
4991    let generated_cloid = Cloid::from_client_order_id(*client_order_id);
4992
4993    if let Some(cloid) = http_client.remove_client_order_id_cloid(client_order_id) {
4994        if terminal {
4995            dispatch_state.insert_terminal_cloid(Ustr::from(&cloid.to_hex()));
4996        }
4997
4998        ws_client.remove_cloid_mapping(&Ustr::from(&cloid.to_hex()));
4999        if cloid == generated_cloid {
5000            return;
5001        }
5002    }
5003
5004    if terminal {
5005        dispatch_state.insert_terminal_cloid(Ustr::from(&generated_cloid.to_hex()));
5006    }
5007
5008    ws_client.remove_cloid_mapping(&Ustr::from(&generated_cloid.to_hex()));
5009}
5010
5011use crate::common::parse::determine_order_list_grouping;
5012
5013#[cfg(test)]
5014mod tests {
5015    use std::{cell::RefCell, rc::Rc, sync::Arc, time::Duration};
5016
5017    use alloy::signers::local::PrivateKeySigner;
5018    use axum::{
5019        Json, Router,
5020        extract::{
5021            State,
5022            ws::{Message, WebSocketUpgrade},
5023        },
5024        response::Response,
5025        routing::{get, post},
5026    };
5027    use futures_util::StreamExt;
5028    use nautilus_common::{
5029        cache::Cache,
5030        clock::VirtualClock,
5031        messages::{ExecutionEvent, ExecutionReport as EngineExecutionReport},
5032    };
5033    use nautilus_core::{
5034        DurationNanos, UUID4, UnixNanos,
5035        string::secret::SecretString,
5036        time::{AtomicTime, get_atomic_clock_realtime},
5037    };
5038    use nautilus_execution::engine::ExecutionEngine;
5039    use nautilus_live::{
5040        ExecutionEventEmitter,
5041        execution::{
5042            context::{OrderContext, OrderIdentity},
5043            failure::CommandFailure,
5044        },
5045        task::TaskGroup,
5046    };
5047    use nautilus_model::{
5048        accounts::{AccountAny, MarginAccount},
5049        enums::{
5050            AccountType, ContingencyType, LiquiditySide, OmsType, OrderSide, OrderStatus,
5051            OrderType, TimeInForce, TriggerType,
5052        },
5053        events::{AccountState, OrderEventAny, OrderPendingCancel, OrderPendingUpdate},
5054        identifiers::{
5055            AccountId, ClientOrderId, InstrumentId, PositionId, StrategyId, TradeId, TraderId,
5056            VenueOrderId,
5057        },
5058        instruments::{CryptoPerpetual, Instrument, InstrumentAny},
5059        orders::{Order, OrderAny, limit::LimitOrder, stop_market::StopMarketOrder},
5060        reports::{FillReport, OrderStatusReport},
5061        types::{AccountBalance, Currency, Money, Price, Quantity},
5062    };
5063    use nautilus_network::{RECONNECTED, websocket::TransportBackend};
5064    use rstest::rstest;
5065    use rust_decimal::Decimal;
5066    use serde_json::{Value, json};
5067    use ustr::Ustr;
5068    use zeroize::Zeroizing;
5069
5070    use super::{
5071        CancelEntry, ExecutionClient, ExecutionClientCore, ExecutionReport, FifoCache,
5072        HyperliquidExecutionClient, HyperliquidExecutionClientConfig, HyperliquidHttpClient,
5073        HyperliquidWebSocketClient, PostRejectionRoute, StagedBracketChild, StagedBracketState,
5074        WsDispatchState, attach_known_client_order_id, build_ouo_resize_request,
5075        can_fast_cancel_order, classify_post_failure, determine_order_list_grouping,
5076        handle_execution_report, reconnect_reports_from_history, register_order_context_into,
5077        resolve_order_legs, split_fast_cancel_requests, ts_venue, validate_order_for_hyperliquid,
5078        validate_query_order_fills,
5079    };
5080    use crate::{
5081        common::{
5082            consts::{HYPERLIQUID_CLIENT_ID, HYPERLIQUID_VENUE},
5083            enums::{HyperliquidEnvironment, HyperliquidProductType},
5084            parse::make_fill_trade_id,
5085            testing::load_test_data,
5086        },
5087        http::{
5088            models::{
5089                Cloid, HyperliquidExchangeAction, HyperliquidExchangeCancelOrderRequest,
5090                HyperliquidExchangeGrouping, HyperliquidExchangeLimitParams,
5091                HyperliquidExchangeOrderKind, HyperliquidExchangePlaceOrderRequest,
5092                HyperliquidExchangeTif, HyperliquidFill, HyperliquidOrderStatusEntry, PerpMeta,
5093            },
5094            parse::{create_instrument_from_def, parse_perp_instruments},
5095        },
5096    };
5097
5098    const TEST_INSTRUMENT_ID: &str = "BTC-USD-PERP.HYPERLIQUID";
5099    const BOOTSTRAP_DELAY: DurationNanos = DurationNanos::from_secs(60);
5100
5101    fn test_emitter() -> (
5102        ExecutionEventEmitter,
5103        tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
5104    ) {
5105        let clock = get_atomic_clock_realtime();
5106        let mut emitter = ExecutionEventEmitter::new(
5107            clock,
5108            TraderId::from("TESTER-001"),
5109            AccountId::from("HYPERLIQUID-001"),
5110            AccountType::Margin,
5111            None,
5112        );
5113        let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
5114        emitter.set_sender(tx);
5115        (emitter, rx)
5116    }
5117
5118    fn drain_events(
5119        rx: &mut tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
5120    ) -> Vec<ExecutionEvent> {
5121        let mut out = Vec::new();
5122        while let Ok(e) = rx.try_recv() {
5123            out.push(e);
5124        }
5125        out
5126    }
5127
5128    fn make_ws_client() -> HyperliquidWebSocketClient {
5129        // `HyperliquidWebSocketClient::new` does not connect, so this is a
5130        // cheap unit-test shim that still exercises the real `cloid_cache`
5131        // mapping APIs used by `handle_execution_report`.
5132        HyperliquidWebSocketClient::new(
5133            Some("wss://test.invalid".to_string()),
5134            HyperliquidEnvironment::Testnet,
5135            None,
5136            TransportBackend::default(),
5137            None,
5138        )
5139    }
5140
5141    fn make_http_client() -> HyperliquidHttpClient {
5142        HyperliquidHttpClient::new(HyperliquidEnvironment::Testnet, 1, None).unwrap()
5143    }
5144
5145    fn make_execution_client() -> HyperliquidExecutionClient {
5146        let wallet = PrivateKeySigner::random();
5147        let key = Zeroizing::new(format!("{:#x}", wallet.to_bytes()));
5148        let core = ExecutionClientCore::new(
5149            TraderId::from("TESTER-001"),
5150            *HYPERLIQUID_CLIENT_ID,
5151            *HYPERLIQUID_VENUE,
5152            OmsType::Netting,
5153            AccountId::from("HYPERLIQUID-001"),
5154            AccountType::Margin,
5155            None,
5156            Rc::new(RefCell::new(Cache::default())),
5157        );
5158        let config = HyperliquidExecutionClientConfig::builder()
5159            .private_key(SecretString::from(key.to_string()))
5160            .environment(HyperliquidEnvironment::Testnet)
5161            .build();
5162
5163        HyperliquidExecutionClient::new(core, config).unwrap()
5164    }
5165
5166    // Matches the order built by `limit_order_with_flags` so registration
5167    // tests can assert the stored context by equality.
5168    fn test_context(client_order_id: ClientOrderId) -> OrderContext {
5169        OrderContext {
5170            identity: OrderIdentity {
5171                client_order_id,
5172                strategy_id: StrategyId::from("S-001"),
5173                instrument_id: InstrumentId::from(TEST_INSTRUMENT_ID),
5174                order_side: OrderSide::Buy,
5175                order_type: OrderType::Limit,
5176            },
5177            quantity: Quantity::from("0.0001"),
5178            price: Some(Price::from("56730.0")),
5179            trigger_price: None,
5180            trigger_type: None,
5181            time_in_force: TimeInForce::Gtc,
5182            is_post_only: false,
5183            is_reduce_only: false,
5184            is_quote_quantity: false,
5185        }
5186    }
5187
5188    #[rstest]
5189    fn test_on_instrument_defers_caching_until_bootstrap() {
5190        let mut client = make_execution_client();
5191        let meta: PerpMeta = load_test_data("http_meta_perp_sample.json");
5192        let defs = parse_perp_instruments(&meta, 0).unwrap();
5193
5194        for def in &defs {
5195            let instrument = create_instrument_from_def(def, UnixNanos::from(123)).unwrap();
5196            client.on_instrument(instrument);
5197        }
5198
5199        for def in &defs {
5200            assert_eq!(
5201                client.http_client.get_asset_index(def.symbol.as_str()),
5202                None
5203            );
5204            assert_eq!(
5205                client.http_client.get_price_precision(def.symbol.as_str()),
5206                None
5207            );
5208        }
5209
5210        assert!(client.ws_client.instruments_cache().is_empty());
5211    }
5212
5213    #[rstest]
5214    #[tokio::test]
5215    async fn test_bootstrap_merges_buffered_instruments(
5216        #[values(false, true)] empty_universe: bool,
5217        #[values(false, true)] fail_initial: bool,
5218    ) {
5219        let meta: PerpMeta = load_test_data("http_meta_perp_sample.json");
5220        let buffered_meta: PerpMeta = serde_json::from_value(json!({"universe": [
5221            {"name": "NEW", "szDecimals": 3, "maxLeverage": 10},
5222            {"name": "BTC", "szDecimals": 4, "maxLeverage": 20},
5223        ]}))
5224        .unwrap();
5225        let mut buffered_defs = parse_perp_instruments(&buffered_meta, 0).unwrap();
5226        buffered_defs[0].asset_index = 42;
5227        buffered_defs[1].asset_index = 73;
5228        let buffered: Vec<_> = buffered_defs
5229            .iter()
5230            .map(|def| create_instrument_from_def(def, UnixNanos::from(123)).unwrap())
5231            .collect();
5232        let failing = Arc::new(std::sync::atomic::AtomicBool::new(fail_initial));
5233        let failing_request = failing.clone();
5234        let app = Router::new().route(
5235            "/info",
5236            post(move |Json(request): Json<Value>| {
5237                let failing = failing_request.clone();
5238                let meta = serde_json::to_value(&meta).unwrap();
5239                async move {
5240                    Json(match request["type"].as_str().unwrap() {
5241                        "spotMeta" => json!({"universe": [], "tokens": []}),
5242                        "allPerpMetas" if failing.load(std::sync::atomic::Ordering::Relaxed) => {
5243                            json!([{"universe": [], "collateralToken": 999}])
5244                        }
5245                        "allPerpMetas" if empty_universe => json!([{"universe": []}]),
5246                        "allPerpMetas" => json!([meta]),
5247                        _ => json!([]),
5248                    })
5249                }
5250            }),
5251        );
5252
5253        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
5254        let address = listener.local_addr().unwrap();
5255        let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
5256        let mut client = make_execution_client();
5257        client
5258            .http_client
5259            .set_base_info_url(format!("http://{address}/info"));
5260        client.on_instrument(buffered[0].clone());
5261        client.on_instrument(buffered[1].clone());
5262        let refreshed =
5263            create_instrument_from_def(&buffered_defs[0], UnixNanos::from(456)).unwrap();
5264        client.on_instrument(refreshed.clone());
5265        if fail_initial {
5266            let error = client
5267                .ensure_instruments_initialized_async()
5268                .await
5269                .unwrap_err();
5270            assert_eq!(
5271                error.to_string(),
5272                "failed to request Hyperliquid instruments"
5273            );
5274            assert!(!client.core.instruments_initialized());
5275            assert_eq!(client.instruments_pending.len(), 3);
5276            assert!(client.ws_client.instruments_cache().is_empty());
5277            failing.store(false, std::sync::atomic::Ordering::Relaxed);
5278        }
5279
5280        client.ensure_instruments_initialized_async().await.unwrap();
5281
5282        let (btc_asset_index, btc_price_precision, btc_size_precision) = if empty_universe {
5283            (73, 2, 4)
5284        } else {
5285            (0, 1, 5)
5286        };
5287
5288        let cache = client.ws_client.instruments_cache();
5289        let snapshot = cache.load();
5290        let btc = snapshot.get(&Ustr::from("BTC")).unwrap();
5291
5292        assert!(client.core.instruments_initialized());
5293        assert!(client.instruments_pending.is_empty());
5294        assert_eq!(snapshot.len(), if empty_universe { 2 } else { 4 });
5295        assert_eq!(client.http_client.get_asset_index("NEW-USD-PERP"), Some(42));
5296        assert_eq!(
5297            client.http_client.get_price_precision("NEW-USD-PERP"),
5298            Some(3)
5299        );
5300        assert_eq!(
5301            serde_json::to_value(snapshot.get(&Ustr::from("NEW")).unwrap()).unwrap(),
5302            serde_json::to_value(refreshed).unwrap()
5303        );
5304        assert_eq!(
5305            client.http_client.get_asset_index("BTC-USD-PERP"),
5306            Some(btc_asset_index)
5307        );
5308        assert_eq!(
5309            client.http_client.get_price_precision("BTC-USD-PERP"),
5310            Some(btc_price_precision)
5311        );
5312        assert_eq!(btc.price_precision(), btc_price_precision);
5313        assert_eq!(btc.size_precision(), btc_size_precision);
5314        server.abort();
5315    }
5316
5317    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
5318    #[ignore = "requires explicit live testnet bootstrap validation"]
5319    async fn test_live_testnet_execution_bootstrap() {
5320        let source = HyperliquidHttpClient::new(HyperliquidEnvironment::Testnet, 30, None).unwrap();
5321        let mut client = make_execution_client();
5322        let (sender, _receiver) = tokio::sync::mpsc::unbounded_channel();
5323        nautilus_common::live::runner::set_exec_event_sender(sender);
5324        client.start().unwrap();
5325
5326        let result = tokio::time::timeout(Duration::from_secs(60), async {
5327            let instruments = source.request_instruments().await.unwrap();
5328            assert!(!instruments.is_empty());
5329            let count = instruments.len();
5330            for instrument in &instruments {
5331                client.on_instrument(instrument.clone());
5332            }
5333
5334            assert!(client.ws_client.instruments_cache().is_empty());
5335
5336            let mass = client.generate_mass_status(None).await.unwrap().unwrap();
5337            assert!(mass.reports_complete());
5338            assert!(mass.order_reports().is_empty());
5339            assert!(mass.fill_reports().is_empty());
5340            assert!(mass.position_reports().is_empty());
5341
5342            let started = std::time::Instant::now();
5343            client.ensure_instruments_initialized_async().await.unwrap();
5344            client.start_ws_stream().await.unwrap();
5345            let cache = client.ws_client.instruments_cache();
5346            let snapshot = cache.load();
5347            for instrument in &instruments {
5348                let cached = snapshot.get(&instrument.raw_symbol().inner()).unwrap();
5349                assert_eq!(cached.id(), instrument.id());
5350                assert_eq!(
5351                    client
5352                        .http_client
5353                        .get_price_precision(cached.symbol().as_str()),
5354                    Some(cached.price_precision()),
5355                );
5356            }
5357
5358            let btc = snapshot.get(&Ustr::from("BTC")).unwrap();
5359            let mut fill = btc_user_fill(
5360                101,
5361                "0xabc",
5362                1_700_000_000_000,
5363                "0x0000000000000000000000000000000a",
5364            );
5365            fill.sz = btc.size_increment().as_decimal();
5366            let parsed = client
5367                .http_client
5368                .fill_reports_from_response(vec![fill.clone()], None)
5369                .unwrap();
5370            let ws_fill = serde_json::from_value(serde_json::to_value(&fill).unwrap()).unwrap();
5371            let report = crate::websocket::parse::parse_ws_fill_report(
5372                &ws_fill,
5373                btc,
5374                client.core.account_id,
5375                client.clock.get_time_ns(),
5376            )
5377            .unwrap();
5378
5379            assert!(client.core.instruments_initialized());
5380            assert!(client.instruments_pending.is_empty());
5381            assert!(client.ws_client.is_active());
5382            assert!(parsed.complete);
5383            assert_eq!(parsed.reports.len(), 1);
5384            assert_eq!(parsed.reports[0].instrument_id, btc.id());
5385            assert_eq!(report.instrument_id, btc.id());
5386            assert_eq!(report.last_qty, btc.size_increment());
5387            assert_eq!(parsed.reports[0].last_qty, report.last_qty);
5388            assert_eq!(parsed.reports[0].last_px, report.last_px);
5389            println!(
5390                "Testnet: {count} instruments, fills parsed, elapsed={:?}",
5391                started.elapsed()
5392            );
5393        })
5394        .await;
5395
5396        client.disconnect().await.unwrap();
5397        result.expect("live testnet bootstrap must complete within 60 seconds");
5398    }
5399
5400    #[rstest]
5401    fn test_on_instrument_registers_asset_index_for_a_new_market() {
5402        // A market listed after the client bootstrapped arrives through the
5403        // message bus, and must become submittable without a restart.
5404        let mut client = make_execution_client();
5405        client.core.set_instruments_initialized();
5406        let meta: PerpMeta = load_test_data("http_meta_perp_sample.json");
5407        let defs = parse_perp_instruments(&meta, 0).unwrap();
5408        let def = &defs[1];
5409        let instrument = create_instrument_from_def(def, UnixNanos::default()).unwrap();
5410
5411        assert_eq!(
5412            client.http_client.get_asset_index(def.symbol.as_str()),
5413            None
5414        );
5415
5416        client.on_instrument(instrument);
5417
5418        assert_eq!(
5419            client.http_client.get_asset_index(def.symbol.as_str()),
5420            Some(def.asset_index),
5421        );
5422    }
5423
5424    #[rstest]
5425    fn test_on_instrument_replaces_asset_index_and_precision() {
5426        let mut client = make_execution_client();
5427        client.core.set_instruments_initialized();
5428        let meta: PerpMeta = load_test_data("http_meta_perp_sample.json");
5429        let mut defs = parse_perp_instruments(&meta, 0).unwrap();
5430        let def = &mut defs[0];
5431        let original = create_instrument_from_def(def, UnixNanos::from(1)).unwrap();
5432        client.on_instrument(original.clone());
5433        let cache = client.ws_client.instruments_cache();
5434        let previous = cache.load();
5435
5436        def.asset_index = 73;
5437        def.price_decimals = 3;
5438        def.tick_size = Decimal::new(1, 3);
5439        def.size_decimals = 4;
5440        def.lot_size = Decimal::new(1, 4);
5441        let refreshed = create_instrument_from_def(def, UnixNanos::from(2)).unwrap();
5442        client.on_instrument(refreshed.clone());
5443
5444        assert_eq!(
5445            client.http_client.get_asset_index(def.symbol.as_str()),
5446            Some(73)
5447        );
5448        assert_eq!(
5449            client.http_client.get_price_precision(def.symbol.as_str()),
5450            Some(3)
5451        );
5452        assert_eq!(
5453            serde_json::to_value(previous.get(&def.raw_symbol).unwrap()).unwrap(),
5454            serde_json::to_value(original).unwrap(),
5455        );
5456        assert_eq!(
5457            serde_json::to_value(cache.load().get(&def.raw_symbol).unwrap()).unwrap(),
5458            serde_json::to_value(refreshed).unwrap(),
5459        );
5460    }
5461
5462    #[rstest]
5463    fn oid_query_attaches_the_known_client_order_id() {
5464        let mut report = make_status_report(None, "55030848197", OrderStatus::Accepted);
5465        let client_order_id = ClientOrderId::new("O-ATTACH-001");
5466
5467        attach_known_client_order_id(&mut report, client_order_id);
5468
5469        assert_eq!(report.client_order_id, Some(client_order_id));
5470        assert_eq!(report.venue_order_id, VenueOrderId::new("55030848197"));
5471        assert_eq!(report.order_status, OrderStatus::Accepted);
5472    }
5473
5474    #[rstest]
5475    fn oid_query_keeps_the_api_reported_client_order_id() {
5476        let mut report = make_status_report(
5477            Some("0x72a3c2f2de33c2c74640ad7f8d11ed74"),
5478            "222222",
5479            OrderStatus::Canceled,
5480        );
5481        let client_order_id = ClientOrderId::new("O-20240101-000002");
5482
5483        attach_known_client_order_id(&mut report, client_order_id);
5484
5485        assert_eq!(
5486            report.client_order_id,
5487            Some(ClientOrderId::new("0x72a3c2f2de33c2c74640ad7f8d11ed74"))
5488        );
5489        assert_eq!(report.venue_order_id, VenueOrderId::new("222222"));
5490        assert_eq!(report.order_status, OrderStatus::Canceled);
5491    }
5492
5493    fn make_status_report(
5494        client_order_id: Option<&str>,
5495        venue_order_id: &str,
5496        status: OrderStatus,
5497    ) -> OrderStatusReport {
5498        make_status_report_with_quantity(
5499            client_order_id,
5500            venue_order_id,
5501            status,
5502            Quantity::from("0.0001"),
5503        )
5504    }
5505
5506    #[rstest]
5507    #[case::account(true)]
5508    #[case::client(false)]
5509    fn test_query_order_fill_validation_rejects_linkage(#[case] wrong_account: bool) {
5510        let context = test_context(ClientOrderId::from("O-QUERY"));
5511        let mut report = make_status_report(Some("O-QUERY"), "100", OrderStatus::Filled);
5512        report.filled_qty = context.quantity;
5513        let mut fill = make_fill_report(Some("O-QUERY"), "100", "TRADE-QUERY");
5514        if wrong_account {
5515            fill.account_id = AccountId::from("HYPERLIQUID-OTHER");
5516        } else {
5517            fill.client_order_id = Some(ClientOrderId::from("OTHER-ORDER"));
5518        }
5519
5520        assert_eq!(
5521            validate_query_order_fills(vec![fill], &report, &context)
5522                .unwrap_err()
5523                .to_string(),
5524            "fill identity or quantity mismatch for venue order 100"
5525        );
5526    }
5527
5528    fn make_status_report_with_quantity(
5529        client_order_id: Option<&str>,
5530        venue_order_id: &str,
5531        status: OrderStatus,
5532        quantity: Quantity,
5533    ) -> OrderStatusReport {
5534        OrderStatusReport::new(
5535            AccountId::from("HYPERLIQUID-001"),
5536            InstrumentId::from(TEST_INSTRUMENT_ID),
5537            client_order_id.map(ClientOrderId::new),
5538            VenueOrderId::new(venue_order_id),
5539            OrderSide::Buy.into(),
5540            OrderType::Limit,
5541            TimeInForce::Gtc,
5542            status,
5543            quantity,
5544            Quantity::from("0"),
5545            UnixNanos::default(),
5546            UnixNanos::default(),
5547            UnixNanos::default(),
5548            Some(UUID4::new()),
5549        )
5550        .with_price(Price::from("56730.0"))
5551    }
5552
5553    fn make_fill_report(
5554        client_order_id: Option<&str>,
5555        venue_order_id: &str,
5556        trade_id: &str,
5557    ) -> FillReport {
5558        make_fill_report_with_qty(
5559            client_order_id,
5560            venue_order_id,
5561            trade_id,
5562            Quantity::from("0.0001"),
5563        )
5564    }
5565
5566    fn make_fill_report_with_qty(
5567        client_order_id: Option<&str>,
5568        venue_order_id: &str,
5569        trade_id: &str,
5570        last_qty: Quantity,
5571    ) -> FillReport {
5572        FillReport::new(
5573            AccountId::from("HYPERLIQUID-001"),
5574            InstrumentId::from(TEST_INSTRUMENT_ID),
5575            VenueOrderId::new(venue_order_id),
5576            TradeId::new(trade_id),
5577            OrderSide::Buy,
5578            last_qty,
5579            Price::from("56730.0"),
5580            Money::new(0.0, Currency::USD()),
5581            LiquiditySide::Taker,
5582            client_order_id.map(ClientOrderId::new),
5583            None,
5584            UnixNanos::default(),
5585            UnixNanos::default(),
5586            Some(UUID4::new()),
5587        )
5588    }
5589
5590    fn cloid_for(id: &str) -> Ustr {
5591        let cloid = Cloid::from_client_order_id(ClientOrderId::from(id));
5592        Ustr::from(&cloid.to_hex())
5593    }
5594
5595    fn limit_order(
5596        id: &str,
5597        reduce_only: bool,
5598        contingency: Option<ContingencyType>,
5599        linked_ids: Option<Vec<&str>>,
5600        parent_id: Option<&str>,
5601    ) -> OrderAny {
5602        OrderAny::Limit(LimitOrder::new(
5603            TraderId::from("TESTER-001"),
5604            StrategyId::from("S-001"),
5605            InstrumentId::from("ETH-USD-PERP.HYPERLIQUID"),
5606            ClientOrderId::from(id),
5607            OrderSide::Buy,
5608            Quantity::from(1),
5609            Price::from("3000.00"),
5610            TimeInForce::Gtc,
5611            None,  // expire_time
5612            false, // post_only
5613            reduce_only,
5614            false, // quote_quantity
5615            None,  // display_qty
5616            None,  // emulation_trigger
5617            None,  // trigger_instrument_id
5618            contingency,
5619            None, // order_list_id
5620            linked_ids.map(|ids| ids.into_iter().map(ClientOrderId::from).collect()),
5621            parent_id.map(ClientOrderId::from),
5622            None, // exec_algorithm_id
5623            None, // exec_algorithm_params
5624            None, // exec_spawn_id
5625            None, // tags
5626            Default::default(),
5627            Default::default(),
5628        ))
5629    }
5630
5631    fn stop_order(
5632        id: &str,
5633        reduce_only: bool,
5634        contingency: Option<ContingencyType>,
5635        linked_ids: Option<Vec<&str>>,
5636        parent_id: Option<&str>,
5637    ) -> OrderAny {
5638        OrderAny::StopMarket(StopMarketOrder::new(
5639            TraderId::from("TESTER-001"),
5640            StrategyId::from("S-001"),
5641            InstrumentId::from("ETH-USD-PERP.HYPERLIQUID"),
5642            ClientOrderId::from(id),
5643            OrderSide::Sell,
5644            Quantity::from(1),
5645            Price::from("2800.00"),
5646            TriggerType::LastPrice,
5647            TimeInForce::Gtc,
5648            None, // expire_time
5649            reduce_only,
5650            false, // quote_quantity
5651            None,  // display_qty
5652            None,  // emulation_trigger
5653            None,  // trigger_instrument_id
5654            contingency,
5655            None, // order_list_id
5656            linked_ids.map(|ids| ids.into_iter().map(ClientOrderId::from).collect()),
5657            parent_id.map(ClientOrderId::from),
5658            None, // exec_algorithm_id
5659            None, // exec_algorithm_params
5660            None, // exec_spawn_id
5661            None, // tags
5662            Default::default(),
5663            Default::default(),
5664        ))
5665    }
5666
5667    fn staged_child(id: &str, sibling_id: &str) -> StagedBracketChild {
5668        StagedBracketChild {
5669            order: limit_order(
5670                id,
5671                true,
5672                Some(ContingencyType::Ouo),
5673                Some(vec![sibling_id]),
5674                Some("O-PARENT"),
5675            ),
5676            request: HyperliquidExchangePlaceOrderRequest {
5677                asset: 4,
5678                is_buy: false,
5679                price: Decimal::from(3_000),
5680                size: Decimal::ONE,
5681                reduce_only: true,
5682                kind: HyperliquidExchangeOrderKind::Limit {
5683                    limit: HyperliquidExchangeLimitParams {
5684                        tif: HyperliquidExchangeTif::Gtc,
5685                    },
5686                },
5687                cloid: Some(Cloid::from_client_order_id(ClientOrderId::from(id))),
5688            },
5689        }
5690    }
5691
5692    #[rstest]
5693    fn test_staged_bracket_activation_links_ouo_siblings_once() {
5694        let parent_id = ClientOrderId::from("O-PARENT");
5695        let first_id = ClientOrderId::from("O-CHILD-1");
5696        let second_id = ClientOrderId::from("O-CHILD-2");
5697        let mut state = StagedBracketState::default();
5698        state.stage(
5699            parent_id,
5700            vec![
5701                staged_child(first_id.as_str(), second_id.as_str()),
5702                staged_child(second_id.as_str(), first_id.as_str()),
5703            ],
5704        );
5705
5706        let activated = state.activate(&parent_id).expect("staged children");
5707        let sibling = state
5708            .take_active_sibling(&first_id)
5709            .expect("active OUO sibling");
5710
5711        assert_eq!(activated.len(), 2);
5712        assert_eq!(sibling.order.client_order_id(), second_id);
5713        assert!(state.activate(&parent_id).is_none());
5714        assert!(state.take_active_sibling(&second_id).is_none());
5715    }
5716
5717    #[rstest]
5718    fn test_restored_active_bracket_rebuilds_ouo_without_reactivation() {
5719        let parent_id = ClientOrderId::from("O-PARENT");
5720        let first_id = ClientOrderId::from("O-CHILD-1");
5721        let second_id = ClientOrderId::from("O-CHILD-2");
5722        let mut state = StagedBracketState::default();
5723        state.restore_active(&[
5724            staged_child(first_id.as_str(), second_id.as_str()),
5725            staged_child(second_id.as_str(), first_id.as_str()),
5726        ]);
5727
5728        let sibling = state
5729            .take_active_sibling(&first_id)
5730            .expect("restored OUO sibling");
5731
5732        assert!(state.activate(&parent_id).is_none());
5733        assert_eq!(sibling.order.client_order_id(), second_id);
5734        assert!(state.take_active_sibling(&second_id).is_none());
5735    }
5736
5737    #[rstest]
5738    fn test_staged_bracket_child_cancel_preserves_other_child_for_parent_fill() {
5739        let parent_id = ClientOrderId::from("O-PARENT");
5740        let first_id = ClientOrderId::from("O-CHILD-1");
5741        let second_id = ClientOrderId::from("O-CHILD-2");
5742        let mut state = StagedBracketState::default();
5743        state.stage(
5744            parent_id,
5745            vec![
5746                staged_child(first_id.as_str(), second_id.as_str()),
5747                staged_child(second_id.as_str(), first_id.as_str()),
5748            ],
5749        );
5750
5751        let canceled = state.cancel_child(&first_id).expect("staged child");
5752        let remaining = state.activate(&parent_id).expect("remaining child");
5753
5754        assert_eq!(canceled.client_order_id(), first_id);
5755        assert_eq!(remaining.len(), 1);
5756        assert_eq!(remaining[0].order.client_order_id(), second_id);
5757    }
5758
5759    #[rstest]
5760    fn test_staged_bracket_parent_cancel_returns_all_unsubmitted_children() {
5761        let parent_id = ClientOrderId::from("O-PARENT");
5762        let first_id = ClientOrderId::from("O-CHILD-1");
5763        let second_id = ClientOrderId::from("O-CHILD-2");
5764        let mut state = StagedBracketState::default();
5765        state.stage(
5766            parent_id,
5767            vec![
5768                staged_child(first_id.as_str(), second_id.as_str()),
5769                staged_child(second_id.as_str(), first_id.as_str()),
5770            ],
5771        );
5772
5773        let canceled = state.cancel_for_parent(&parent_id);
5774        let canceled_ids = canceled
5775            .iter()
5776            .map(Order::client_order_id)
5777            .collect::<Vec<_>>();
5778
5779        assert_eq!(canceled_ids, vec![first_id, second_id]);
5780        assert!(state.activate(&parent_id).is_none());
5781    }
5782
5783    #[rstest]
5784    fn test_build_ouo_resize_request_sends_sibling_leaves_quantity() {
5785        let sibling = staged_child("O-CHILD-2", "O-CHILD-1");
5786
5787        let request =
5788            build_ouo_resize_request(&sibling, Quantity::from("0.7"), Quantity::from("0.2"))
5789                .expect("resized request");
5790        let exhausted =
5791            build_ouo_resize_request(&sibling, Quantity::from("0.2"), Quantity::from("0.2"));
5792
5793        assert_eq!(request.size, Decimal::new(5, 1));
5794        assert_eq!(request.cloid, sibling.request.cloid);
5795        assert!(exhausted.is_none());
5796    }
5797
5798    #[rstest]
5799    #[case::independent_orders(
5800        vec![
5801            limit_order("O-001", false, None, None, None),
5802            limit_order("O-002", false, None, None, None),
5803        ],
5804        HyperliquidExchangeGrouping::Na,
5805    )]
5806    #[case::bracket_oto(
5807        vec![
5808            limit_order("O-001", false, Some(ContingencyType::Oto), Some(vec!["O-002", "O-003"]), None),
5809            limit_order("O-002", true, Some(ContingencyType::Oco), Some(vec!["O-003"]), Some("O-001")),
5810            stop_order("O-003", true, Some(ContingencyType::Oco), Some(vec!["O-002"]), Some("O-001")),
5811        ],
5812        HyperliquidExchangeGrouping::NormalTpsl,
5813    )]
5814    #[case::bracket_oto_with_factory_ouo_children(
5815        vec![
5816            limit_order("O-001", false, Some(ContingencyType::Oto), Some(vec!["O-002", "O-003"]), None),
5817            limit_order("O-002", true, Some(ContingencyType::Ouo), Some(vec!["O-003"]), Some("O-001")),
5818            stop_order("O-003", true, Some(ContingencyType::Ouo), Some(vec!["O-002"]), Some("O-001")),
5819        ],
5820        HyperliquidExchangeGrouping::NormalTpsl,
5821    )]
5822    #[case::oto_not_bracket_shaped(
5823        vec![
5824            limit_order("O-001", false, Some(ContingencyType::Oto), Some(vec!["O-002"]), None),
5825            limit_order("O-002", false, Some(ContingencyType::Oto), Some(vec!["O-001"]), None),
5826        ],
5827        HyperliquidExchangeGrouping::Na,
5828    )]
5829    #[case::oco_all_reduce_only(
5830        vec![
5831            limit_order("O-001", true, Some(ContingencyType::Oco), Some(vec!["O-002"]), None),
5832            stop_order("O-002", true, Some(ContingencyType::Oco), Some(vec!["O-001"]), None),
5833        ],
5834        HyperliquidExchangeGrouping::PositionTpsl,
5835    )]
5836    #[case::oco_not_all_reduce_only(
5837        vec![
5838            limit_order("O-001", false, Some(ContingencyType::Oco), Some(vec!["O-002"]), None),
5839            stop_order("O-002", true, Some(ContingencyType::Oco), Some(vec!["O-001"]), None),
5840        ],
5841        HyperliquidExchangeGrouping::Na,
5842    )]
5843    #[case::oto_with_non_oco_children(
5844        vec![
5845            limit_order("O-001", false, Some(ContingencyType::Oto), Some(vec!["O-002", "O-003"]), None),
5846            limit_order("O-002", true, None, None, None),
5847            stop_order("O-003", true, None, None, None),
5848        ],
5849        HyperliquidExchangeGrouping::Na,
5850    )]
5851    #[case::mixed_oco_and_plain_reduce_only(
5852        vec![
5853            limit_order("O-001", true, Some(ContingencyType::Oco), Some(vec!["O-002"]), None),
5854            stop_order("O-002", true, None, None, None),
5855        ],
5856        HyperliquidExchangeGrouping::Na,
5857    )]
5858    #[case::unlinked_oco_reduce_only(
5859        vec![
5860            limit_order("O-001", true, Some(ContingencyType::Oco), Some(vec!["O-099"]), None),
5861            stop_order("O-002", true, Some(ContingencyType::Oco), Some(vec!["O-098"]), None),
5862        ],
5863        HyperliquidExchangeGrouping::Na,
5864    )]
5865    #[case::single_order(
5866        vec![limit_order("O-001", false, None, None, None)],
5867        HyperliquidExchangeGrouping::Na,
5868    )]
5869    fn test_determine_order_list_grouping(
5870        #[case] orders: Vec<OrderAny>,
5871        #[case] expected: HyperliquidExchangeGrouping,
5872    ) {
5873        let result = determine_order_list_grouping(&orders);
5874        assert_eq!(result, expected);
5875    }
5876
5877    #[rstest]
5878    #[case::market(Some(OrderType::Market), true)]
5879    #[case::limit(Some(OrderType::Limit), true)]
5880    #[case::stop_market(Some(OrderType::StopMarket), false)]
5881    #[case::unknown(None, false)]
5882    fn test_can_fast_cancel_order_only_allows_plain_order_types(
5883        #[case] order_type: Option<OrderType>,
5884        #[case] expected: bool,
5885    ) {
5886        assert_eq!(can_fast_cancel_order(order_type), expected);
5887    }
5888
5889    #[rstest]
5890    fn test_split_fast_cancel_requests_preserves_request_entry_alignment() {
5891        let requests = vec![
5892            (10_u64, cancel_entry("O-FAST-1", true)),
5893            (20_u64, cancel_entry("O-NORMAL-1", false)),
5894            (30_u64, cancel_entry("O-FAST-2", true)),
5895            (40_u64, cancel_entry("O-NORMAL-2", false)),
5896        ];
5897
5898        let (fast_requests, fast_entries, normal_requests, normal_entries) =
5899            split_fast_cancel_requests(requests);
5900
5901        assert_eq!(fast_requests, vec![10, 30]);
5902        assert_eq!(
5903            client_order_ids(&fast_entries),
5904            vec![
5905                ClientOrderId::from("O-FAST-1"),
5906                ClientOrderId::from("O-FAST-2"),
5907            ]
5908        );
5909        assert!(fast_entries.iter().all(|entry| entry.fast));
5910        assert_eq!(normal_requests, vec![20, 40]);
5911        assert_eq!(
5912            client_order_ids(&normal_entries),
5913            vec![
5914                ClientOrderId::from("O-NORMAL-1"),
5915                ClientOrderId::from("O-NORMAL-2"),
5916            ]
5917        );
5918        assert!(normal_entries.iter().all(|entry| !entry.fast));
5919    }
5920
5921    fn cancel_entry(client_order_id: &str, fast: bool) -> CancelEntry {
5922        CancelEntry {
5923            command_id: UUID4::default(),
5924            strategy_id: StrategyId::from("S-001"),
5925            instrument_id: InstrumentId::from(TEST_INSTRUMENT_ID),
5926            client_order_id: ClientOrderId::from(client_order_id),
5927            venue_order_id: Some(VenueOrderId::new("123")),
5928            symbol: Ustr::from("BTC-USD-PERP"),
5929            fast,
5930        }
5931    }
5932
5933    fn client_order_ids(entries: &[CancelEntry]) -> Vec<ClientOrderId> {
5934        entries.iter().map(|entry| entry.client_order_id).collect()
5935    }
5936
5937    fn limit_order_with_flags(id: &str, quote_quantity: bool, post_only: bool) -> OrderAny {
5938        OrderAny::Limit(LimitOrder::new(
5939            TraderId::from("TESTER-001"),
5940            StrategyId::from("S-001"),
5941            InstrumentId::from(TEST_INSTRUMENT_ID),
5942            ClientOrderId::from(id),
5943            OrderSide::Buy,
5944            Quantity::from("0.0001"),
5945            Price::from("56730.0"),
5946            TimeInForce::Gtc,
5947            None,
5948            post_only,
5949            false,
5950            quote_quantity,
5951            None,
5952            None,
5953            None,
5954            None,
5955            None,
5956            None,
5957            None,
5958            None,
5959            None,
5960            None,
5961            None,
5962            Default::default(),
5963            Default::default(),
5964        ))
5965    }
5966
5967    #[rstest]
5968    fn test_register_order_context_registers_regular_order() {
5969        let state = WsDispatchState::new();
5970        let client_order_id = ClientOrderId::from("O-REG-001");
5971        let order = limit_order_with_flags("O-REG-001", false, false);
5972
5973        register_order_context_into(&state, &order);
5974
5975        assert_eq!(
5976            state.lookup_context(&client_order_id),
5977            Some(test_context(client_order_id)),
5978        );
5979    }
5980
5981    #[rstest]
5982    fn test_register_order_context_skips_quote_quantity_order() {
5983        let state = WsDispatchState::new();
5984        let order = limit_order_with_flags("O-QQ-001", true, false);
5985
5986        register_order_context_into(&state, &order);
5987
5988        // Quote-quantity orders flow through the untracked path so the engine
5989        // reconciles them from status reports; registering would make the
5990        // cumulative-fill comparison mismatch base-unit fills against the
5991        // quote-unit tracked quantity and leave the order stuck "open".
5992        assert!(
5993            state
5994                .lookup_context(&ClientOrderId::from("O-QQ-001"))
5995                .is_none()
5996        );
5997    }
5998
5999    #[rstest]
6000    #[case::canceled(OrderStatus::Canceled)]
6001    #[case::rejected(OrderStatus::Rejected)]
6002    fn test_handle_execution_report_skip_keeps_cloid_mapping(#[case] status: OrderStatus) {
6003        // Regression guard for GH-3827: when the dispatch returns Skip (e.g.
6004        // the stale cancel leg of a cancel-replace), the cloid mapping must
6005        // stay in place so the still-open replacement order can still be
6006        // resolved by subsequent events.
6007        let ws_client = make_ws_client();
6008        let (emitter, mut rx) = test_emitter();
6009        let state = WsDispatchState::new();
6010        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
6011
6012        let cid = ClientOrderId::from("O-HER-SKIP");
6013        state.register_context(test_context(cid));
6014        state.insert_accepted(cid);
6015        state.record_venue_order_id(cid, VenueOrderId::new("new-voi"));
6016
6017        ws_client.cache_cloid_mapping(cloid_for("O-HER-SKIP"), cid);
6018
6019        let report = make_status_report(Some("O-HER-SKIP"), "old-voi", status);
6020        let (terminal_skipped, corrective) = handle_execution_report(
6021            ExecutionReport::Order(report),
6022            &state,
6023            &emitter,
6024            &ws_client,
6025            &make_http_client(),
6026            &mut pending_cloids,
6027            UnixNanos::default(),
6028        );
6029
6030        assert!(terminal_skipped);
6031        assert!(corrective.is_none());
6032        assert!(drain_events(&mut rx).is_empty());
6033        assert_eq!(
6034            ws_client.get_cloid_mapping(&cloid_for("O-HER-SKIP")),
6035            Some(cid)
6036        );
6037        assert!(state.lookup_context(&cid).is_some());
6038    }
6039
6040    #[rstest]
6041    #[case::pending_rejection(OrderStatus::Rejected)]
6042    #[case::filled_replay(OrderStatus::Filled)]
6043    fn test_handle_execution_report_skipped_terminal_keeps_bracket_handling(
6044        #[case] status: OrderStatus,
6045    ) {
6046        let ws_client = make_ws_client();
6047        let (emitter, mut rx) = test_emitter();
6048        let state = WsDispatchState::new();
6049        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
6050        let cid = ClientOrderId::from("O-HER-BRACKET");
6051        state.register_context(test_context(cid));
6052        match status {
6053            OrderStatus::Rejected => state.mark_submission_pending(cid),
6054            OrderStatus::Filled => {
6055                state.insert_filled(cid);
6056                state.cleanup_terminal(&cid);
6057            }
6058            _ => unreachable!(),
6059        }
6060
6061        ws_client.cache_cloid_mapping(cloid_for("O-HER-BRACKET"), cid);
6062        let report = make_status_report(Some("O-HER-BRACKET"), "v-bracket", status);
6063        let (terminal_skipped, corrective) = handle_execution_report(
6064            ExecutionReport::Order(report),
6065            &state,
6066            &emitter,
6067            &ws_client,
6068            &make_http_client(),
6069            &mut pending_cloids,
6070            UnixNanos::default(),
6071        );
6072
6073        assert!(!terminal_skipped);
6074        assert!(corrective.is_none());
6075        assert!(drain_events(&mut rx).is_empty());
6076        assert_eq!(
6077            ws_client.get_cloid_mapping(&cloid_for("O-HER-BRACKET")),
6078            Some(cid)
6079        );
6080    }
6081
6082    #[rstest]
6083    #[case::adapter_issued(None, 1)]
6084    #[case::adapter_issued_chain(None, 2)]
6085    #[case::strategy_modify(Some(OrderStatus::PendingUpdate), 1)]
6086    #[case::strategy_cancel(Some(OrderStatus::PendingCancel), 1)]
6087    fn test_handle_execution_report_closed_replacement(
6088        #[case] pending_status: Option<OrderStatus>,
6089        #[case] modifies: usize,
6090        #[values(false, true)] recovery: bool,
6091        #[values(false, true)] replacement_first: bool,
6092        #[values("0", "0.00004")] filled: &str,
6093    ) {
6094        let ws_client = make_ws_client();
6095        let mut http_client = make_http_client();
6096        http_client.set_account_id(AccountId::from("HYPERLIQUID-001"));
6097        let meta: PerpMeta = load_test_data("http_meta_perp_sample.json");
6098        let defs = parse_perp_instruments(&meta, 0).unwrap();
6099        http_client
6100            .cache_instrument(&create_instrument_from_def(&defs[0], UnixNanos::default()).unwrap());
6101        let (emitter, mut rx) = test_emitter();
6102        let state = WsDispatchState::new();
6103        let mut pending_cloids = FifoCache::new();
6104        let cid = ClientOrderId::new("O-CLOSED-REPLACEMENT");
6105        let original = VenueOrderId::new("100");
6106        let replacement = VenueOrderId::new((100 + modifies).to_string());
6107        let cloid = Cloid::from_client_order_id(cid);
6108        let mut order = limit_order_with_flags(cid.as_str(), false, false);
6109        state.register_context(OrderContext::from(&order));
6110        ws_client.cache_cloid_mapping(Ustr::from(&cloid.to_hex()), cid);
6111        http_client.cache_client_order_id_cloid(cid, cloid);
6112        super::dispatch_order_event(
6113            &make_status_report(Some(cid.as_str()), "100", OrderStatus::Accepted),
6114            &state,
6115            &emitter,
6116            UnixNanos::default(),
6117        );
6118        let filled_qty = Quantity::from(filled);
6119        if filled_qty > Quantity::zero(filled_qty.precision) {
6120            super::dispatch_order_fill(
6121                &make_fill_report_with_qty(Some(cid.as_str()), "100", "T-OLD", filled_qty),
6122                &state,
6123                &emitter,
6124                UnixNanos::default(),
6125            );
6126        }
6127
6128        for event in drain_events(&mut rx) {
6129            let ExecutionEvent::Order(event) = event else {
6130                panic!("expected order event, received {event:?}");
6131            };
6132
6133            order.apply(event).unwrap();
6134        }
6135
6136        let pending = match pending_status {
6137            Some(OrderStatus::PendingUpdate) => {
6138                Some(OrderEventAny::PendingUpdate(OrderPendingUpdate::new(
6139                    order.trader_id(),
6140                    order.strategy_id(),
6141                    order.instrument_id(),
6142                    cid,
6143                    order.account_id(),
6144                    UUID4::new(),
6145                    UnixNanos::default(),
6146                    UnixNanos::default(),
6147                    false,
6148                    Some(original),
6149                )))
6150            }
6151            Some(OrderStatus::PendingCancel) => {
6152                Some(OrderEventAny::PendingCancel(OrderPendingCancel::new(
6153                    order.trader_id(),
6154                    order.strategy_id(),
6155                    order.instrument_id(),
6156                    cid,
6157                    order.account_id(),
6158                    UUID4::new(),
6159                    UnixNanos::default(),
6160                    UnixNanos::default(),
6161                    false,
6162                    Some(original),
6163                )))
6164            }
6165            None => None,
6166            _ => unreachable!(),
6167        };
6168
6169        if let Some(event) = pending {
6170            order.apply(event).unwrap();
6171        }
6172
6173        let targets = [Quantity::from("0.0002"), Quantity::from("0.0003")];
6174        let target = targets[modifies - 1];
6175        for quantity in targets.into_iter().take(modifies) {
6176            state.mark_pending_modify(cid, original, quantity);
6177            let mut request = staged_child(cid.as_str(), "O-SIBLING").request;
6178            request.size = quantity.as_decimal();
6179            state.stash_modify_request(cid, request);
6180        }
6181
6182        let mut old_cancel = make_status_report(Some(cid.as_str()), "100", OrderStatus::Canceled);
6183        old_cancel.ts_accepted = UnixNanos::from(1_000_000);
6184        old_cancel.ts_last = UnixNanos::from(2_000_000);
6185        let mut new_cancel = make_status_report(Some(cid.as_str()), "101", OrderStatus::Canceled);
6186        new_cancel.price = Some(Price::from("56740.0"));
6187        new_cancel.ts_accepted = UnixNanos::from(2_000_000);
6188        new_cancel.ts_last = UnixNanos::from(3_000_000);
6189        let mut final_cancel = new_cancel.clone();
6190        final_cancel.venue_order_id = replacement;
6191        final_cancel.ts_accepted = UnixNanos::from((1 + modifies as u64) * 1_000_000);
6192        final_cancel.ts_last = UnixNanos::from((2 + modifies as u64) * 1_000_000);
6193        let mut reports: Vec<_> = [old_cancel.clone(), new_cancel, final_cancel.clone()]
6194            .into_iter()
6195            .take(modifies + 1)
6196            .collect();
6197
6198        if replacement_first {
6199            reports.rotate_left(1);
6200        }
6201
6202        let reports = if recovery {
6203            let entries = reports
6204                .iter()
6205                .map(|report| {
6206                    let mut entry = btc_order_entry(
6207                        report.venue_order_id.as_str().parse().unwrap(),
6208                        "canceled",
6209                        report.ts_last.as_millis(),
6210                        &cloid.to_hex(),
6211                    );
6212                    entry.order.timestamp = report.ts_accepted.as_millis();
6213                    entry.order.limit_px = report.price.unwrap().as_decimal();
6214                    entry.order.sz = Decimal::new(1, 4);
6215                    entry.order.orig_sz = Decimal::new(1, 4);
6216                    entry
6217                })
6218                .collect();
6219
6220            reconnect_reports_from_history(
6221                vec![],
6222                entries,
6223                UnixNanos::default(),
6224                &ws_client,
6225                &http_client,
6226                &state,
6227            )
6228            .unwrap()
6229        } else {
6230            reports.into_iter().map(ExecutionReport::Order).collect()
6231        };
6232
6233        let mut terminal_skipped = Vec::new();
6234
6235        for report in reports {
6236            let (skipped, corrective) = handle_execution_report(
6237                report,
6238                &state,
6239                &emitter,
6240                &ws_client,
6241                &http_client,
6242                &mut pending_cloids,
6243                UnixNanos::default(),
6244            );
6245            terminal_skipped.push(skipped);
6246            assert!(corrective.is_none());
6247        }
6248
6249        let events = drain_events(&mut rx);
6250        assert_eq!(events.len(), modifies + 1);
6251        assert!(
6252            events[..modifies]
6253                .iter()
6254                .all(|event| matches!(event, ExecutionEvent::Order(OrderEventAny::Updated(_)),))
6255        );
6256        assert!(matches!(
6257            events[modifies],
6258            ExecutionEvent::Order(OrderEventAny::Canceled(_))
6259        ));
6260
6261        for event in events {
6262            let ExecutionEvent::Order(event) = event else {
6263                panic!("expected order event, received {event:?}");
6264            };
6265
6266            order.apply(event).unwrap();
6267        }
6268
6269        let mut expected_skipped = vec![!recovery; modifies + 1];
6270        expected_skipped[modifies] = false;
6271        if replacement_first && !recovery {
6272            expected_skipped.rotate_left(1);
6273        }
6274
6275        assert_eq!(terminal_skipped, expected_skipped);
6276        assert_eq!(order.status(), OrderStatus::Canceled);
6277        assert_eq!(order.venue_order_id(), Some(replacement));
6278        assert_eq!(order.quantity(), target);
6279        assert_eq!(order.filled_qty(), filled_qty);
6280        assert_eq!(order.leaves_qty(), target - filled_qty);
6281        assert_eq!(order.price(), Some(Price::from("56740.0")));
6282        assert_eq!(order.account_id(), Some(AccountId::from("HYPERLIQUID-001")));
6283        assert_eq!(state.pending_modify(&cid), None);
6284        assert_eq!(state.lookup_context(&cid), None);
6285        assert_eq!(
6286            ws_client.get_cloid_mapping(&Ustr::from(&cloid.to_hex())),
6287            None
6288        );
6289        assert_eq!(http_client.cached_client_order_id_cloid(&cid), None);
6290
6291        for report in [final_cancel.clone(), old_cancel, final_cancel] {
6292            let (skipped, corrective) = handle_execution_report(
6293                ExecutionReport::Order(report),
6294                &state,
6295                &emitter,
6296                &ws_client,
6297                &http_client,
6298                &mut pending_cloids,
6299                UnixNanos::default(),
6300            );
6301            assert!(skipped);
6302            assert!(corrective.is_none());
6303        }
6304
6305        assert!(drain_events(&mut rx).is_empty());
6306    }
6307
6308    #[rstest]
6309    fn test_recovery_canceled_replacement_preserves_fill() {
6310        let ws_client = make_ws_client();
6311        let http_client = make_http_client();
6312        let (emitter, mut rx) = test_emitter();
6313        let state = WsDispatchState::new();
6314        let mut pending_cloids = FifoCache::new();
6315        let cid = ClientOrderId::new("O-CLOSED-FILL");
6316        let mut order = limit_order_with_flags(cid.as_str(), false, false);
6317        state.register_context(OrderContext::from(&order));
6318        super::dispatch_order_event(
6319            &make_status_report(Some(cid.as_str()), "100", OrderStatus::Accepted),
6320            &state,
6321            &emitter,
6322            UnixNanos::default(),
6323        );
6324        super::dispatch_order_fill(
6325            &make_fill_report_with_qty(
6326                Some(cid.as_str()),
6327                "100",
6328                "T-ORIGINAL",
6329                Quantity::from("0.00002"),
6330            ),
6331            &state,
6332            &emitter,
6333            UnixNanos::default(),
6334        );
6335        let target = Quantity::from("0.0002");
6336        state.mark_pending_modify(cid, VenueOrderId::new("100"), target);
6337        let mut request = staged_child(cid.as_str(), "O-SIBLING").request;
6338        request.size = target.as_decimal();
6339        state.stash_modify_request(cid, request);
6340        let mut reports = resolve_order_legs(
6341            vec![
6342                make_status_report(Some(cid.as_str()), "100", OrderStatus::Canceled),
6343                make_status_report(Some(cid.as_str()), "101", OrderStatus::Canceled),
6344            ],
6345            &state,
6346        )
6347        .into_iter()
6348        .map(ExecutionReport::Order)
6349        .collect::<Vec<_>>();
6350        reports.insert(
6351            1,
6352            ExecutionReport::Fill(make_fill_report_with_qty(
6353                Some(cid.as_str()),
6354                "101",
6355                "T-REPLACEMENT",
6356                Quantity::from("0.00004"),
6357            )),
6358        );
6359
6360        for report in reports {
6361            let (skipped, corrective) = handle_execution_report(
6362                report,
6363                &state,
6364                &emitter,
6365                &ws_client,
6366                &http_client,
6367                &mut pending_cloids,
6368                UnixNanos::default(),
6369            );
6370            assert!(!skipped);
6371            assert!(corrective.is_none());
6372        }
6373
6374        let events = drain_events(&mut rx);
6375        assert!(matches!(
6376            events.as_slice(),
6377            [
6378                ExecutionEvent::Order(OrderEventAny::Accepted(_)),
6379                ExecutionEvent::Order(OrderEventAny::Filled(_)),
6380                ExecutionEvent::Order(OrderEventAny::Updated(_)),
6381                ExecutionEvent::Order(OrderEventAny::Filled(_)),
6382                ExecutionEvent::Order(OrderEventAny::Canceled(_)),
6383            ]
6384        ));
6385
6386        for event in events {
6387            let ExecutionEvent::Order(event) = event else {
6388                panic!("expected order event, received {event:?}");
6389            };
6390
6391            order.apply(event).unwrap();
6392        }
6393
6394        assert_eq!(order.status(), OrderStatus::Canceled);
6395        assert_eq!(order.venue_order_id(), Some(VenueOrderId::new("101")));
6396        assert_eq!(order.quantity(), target);
6397        assert_eq!(order.filled_qty(), Quantity::from("0.00006"));
6398        assert_eq!(order.leaves_qty(), Quantity::from("0.00014"));
6399        assert_eq!(state.pending_modify(&cid), None);
6400    }
6401
6402    #[rstest]
6403    fn test_canceled_replacement_preserves_late_fill() {
6404        let ws_client = make_ws_client();
6405        let http_client = make_http_client();
6406        let (emitter, mut rx) = test_emitter();
6407        let state = WsDispatchState::new();
6408        let mut pending_cloids = FifoCache::new();
6409        let cid = ClientOrderId::new("O-CLOSED-LATE-FILL");
6410        let mut order = limit_order_with_flags(cid.as_str(), false, false);
6411        state.register_context(OrderContext::from(&order));
6412        super::dispatch_order_event(
6413            &make_status_report(Some(cid.as_str()), "100", OrderStatus::Accepted),
6414            &state,
6415            &emitter,
6416            UnixNanos::default(),
6417        );
6418        let old_fill = make_fill_report_with_qty(
6419            Some(cid.as_str()),
6420            "100",
6421            "T-OLD-LATE",
6422            Quantity::from("0.00002"),
6423        );
6424        super::dispatch_order_fill(&old_fill, &state, &emitter, UnixNanos::default());
6425        let target = Quantity::from("0.0002");
6426        state.mark_pending_modify(cid, VenueOrderId::new("100"), target);
6427
6428        for oid in ["100", "101"] {
6429            let (_, corrective) = handle_execution_report(
6430                ExecutionReport::Order(make_status_report(
6431                    Some(cid.as_str()),
6432                    oid,
6433                    OrderStatus::Canceled,
6434                )),
6435                &state,
6436                &emitter,
6437                &ws_client,
6438                &http_client,
6439                &mut pending_cloids,
6440                UnixNanos::default(),
6441            );
6442            assert!(corrective.is_none());
6443        }
6444
6445        for event in drain_events(&mut rx) {
6446            let ExecutionEvent::Order(event) = event else {
6447                panic!("expected order event");
6448            };
6449
6450            order.apply(event).unwrap();
6451        }
6452
6453        let late_fill = make_fill_report_with_qty(
6454            Some(cid.as_str()),
6455            "101",
6456            "T-NEW-LATE",
6457            Quantity::from("0.00004"),
6458        );
6459
6460        for fill in [old_fill, late_fill.clone(), late_fill.clone()] {
6461            handle_execution_report(
6462                ExecutionReport::Fill(fill),
6463                &state,
6464                &emitter,
6465                &ws_client,
6466                &http_client,
6467                &mut pending_cloids,
6468                UnixNanos::default(),
6469            );
6470        }
6471
6472        let events = drain_events(&mut rx);
6473
6474        let [ExecutionEvent::Report(EngineExecutionReport::Fill(report))] = events.as_slice()
6475        else {
6476            panic!("expected one late fill report, received {events:?}");
6477        };
6478
6479        assert_eq!(report.as_ref(), &late_fill);
6480        assert_eq!(order.status(), OrderStatus::Canceled);
6481        assert_eq!(order.venue_order_id(), Some(VenueOrderId::new("101")));
6482        assert_eq!(order.quantity(), target);
6483        assert_eq!(order.filled_qty(), Quantity::from("0.00002"));
6484    }
6485
6486    #[rstest]
6487    fn test_canceled_stop_replacement_applies_to_order(
6488        #[values(false, true)] recovery: bool,
6489        #[values(false, true)] strategy_modify: bool,
6490    ) {
6491        let ws_client = make_ws_client();
6492        let http_client = make_http_client();
6493        let (emitter, mut rx) = test_emitter();
6494        let state = WsDispatchState::new();
6495        let mut pending_cloids = FifoCache::new();
6496        let cid = ClientOrderId::new("O-CLOSED-STOP");
6497        let mut order = stop_order(
6498            cid.as_str(),
6499            true,
6500            Some(ContingencyType::Ouo),
6501            Some(vec!["O-TAKE-PROFIT"]),
6502            Some("O-PARENT"),
6503        );
6504        state.register_context(OrderContext::from(&order));
6505        super::dispatch_order_event(
6506            &make_status_report(Some(cid.as_str()), "100", OrderStatus::Accepted),
6507            &state,
6508            &emitter,
6509            UnixNanos::default(),
6510        );
6511
6512        for event in drain_events(&mut rx) {
6513            let ExecutionEvent::Order(event) = event else {
6514                panic!("expected order event");
6515            };
6516
6517            order.apply(event).unwrap();
6518        }
6519
6520        if strategy_modify {
6521            order
6522                .apply(OrderEventAny::PendingUpdate(OrderPendingUpdate::new(
6523                    order.trader_id(),
6524                    order.strategy_id(),
6525                    order.instrument_id(),
6526                    cid,
6527                    order.account_id(),
6528                    UUID4::new(),
6529                    UnixNanos::default(),
6530                    UnixNanos::default(),
6531                    false,
6532                    Some(VenueOrderId::new("100")),
6533                )))
6534                .unwrap();
6535        }
6536
6537        let target = Quantity::from("0.8");
6538        state.mark_pending_modify(cid, VenueOrderId::new("100"), target);
6539        let mut reports: Vec<_> = ["100", "101"]
6540            .into_iter()
6541            .map(|oid| {
6542                let mut report = make_status_report(Some(cid.as_str()), oid, OrderStatus::Canceled);
6543                report.instrument_id = order.instrument_id();
6544                report.order_type = OrderType::StopMarket;
6545                report.trigger_price = Some(Price::from("2790.00"));
6546                report
6547            })
6548            .collect();
6549
6550        if recovery {
6551            reports = resolve_order_legs(reports, &state);
6552        }
6553
6554        for report in reports {
6555            let (_, corrective) = handle_execution_report(
6556                ExecutionReport::Order(report),
6557                &state,
6558                &emitter,
6559                &ws_client,
6560                &http_client,
6561                &mut pending_cloids,
6562                UnixNanos::default(),
6563            );
6564            assert!(corrective.is_none());
6565        }
6566
6567        let events = drain_events(&mut rx);
6568        assert!(matches!(
6569            events.as_slice(),
6570            [
6571                ExecutionEvent::Order(OrderEventAny::Updated(_)),
6572                ExecutionEvent::Order(OrderEventAny::Canceled(_))
6573            ]
6574        ));
6575
6576        for event in events {
6577            let ExecutionEvent::Order(event) = event else {
6578                panic!("expected order event");
6579            };
6580
6581            order.apply(event).unwrap();
6582        }
6583
6584        assert_eq!(order.status(), OrderStatus::Canceled);
6585        assert_eq!(order.venue_order_id(), Some(VenueOrderId::new("101")));
6586        assert_eq!(order.quantity(), target);
6587        assert_eq!(order.price(), None);
6588        assert_eq!(order.trigger_price(), Some(Price::from("2790.00")));
6589        assert_eq!(order.filled_qty().as_decimal(), Decimal::ZERO);
6590        assert_eq!(order.leaves_qty(), target);
6591    }
6592
6593    #[rstest]
6594    #[case::fill_before_status(2, None, "0.00005")]
6595    #[case::status_before_fill(0, None, "0.00005")]
6596    #[case::status_between_fills(1, None, "0.00005")]
6597    #[case::dispatch_fill_evidence(2, None, "0")]
6598    #[case::post_before_fill(0, Some(true), "0.00005")]
6599    #[case::post_after_fill(2, Some(true), "0")]
6600    #[case::post_success_before_fill(0, Some(false), "0.00005")]
6601    #[case::post_success_after_fill(2, Some(false), "0.00005")]
6602    #[tokio::test]
6603    async fn test_partial_fill_rejection_preserves_order_and_position(
6604        #[case] fills_before_status: usize,
6605        #[case] post_rejection: Option<bool>,
6606        #[case] report_filled_qty: &str,
6607    ) {
6608        let ws_client = make_ws_client();
6609        let http_client = make_http_client();
6610        let (emitter, mut rx) = test_emitter();
6611        let state = Arc::new(WsDispatchState::new());
6612        let mut pending_cloids = FifoCache::new();
6613        let cid = ClientOrderId::new("O-PARTIAL-REJECTION");
6614        let order = limit_order_with_flags(cid.as_str(), false, false);
6615        let context = OrderContext::from(&order);
6616        state.register_context(context);
6617        if post_rejection.is_some() {
6618            state.mark_submission_pending(cid);
6619        }
6620
6621        ws_client.cache_cloid_mapping(cloid_for(cid.as_str()), cid);
6622
6623        let instrument = InstrumentAny::CryptoPerpetual(
6624            CryptoPerpetual::builder()
6625                .instrument_id(context.identity.instrument_id)
6626                .raw_symbol("BTC".into())
6627                .base_currency(Currency::BTC())
6628                .quote_currency(Currency::USD())
6629                .settlement_currency(Currency::USD())
6630                .is_inverse(false)
6631                .price_precision(1)
6632                .size_precision(5)
6633                .price_increment(Price::from("0.1"))
6634                .size_increment(Quantity::from("0.00001"))
6635                .ts_event(UnixNanos::default())
6636                .ts_init(UnixNanos::default())
6637                .build()
6638                .unwrap(),
6639        );
6640        let cache = Rc::new(RefCell::new(Cache::default()));
6641        cache.borrow_mut().add_instrument(instrument).unwrap();
6642        cache
6643            .borrow_mut()
6644            .add_order(order.clone(), None, None, true)
6645            .unwrap();
6646
6647        let account_state = AccountState::new(
6648            AccountId::from("HYPERLIQUID-001"),
6649            AccountType::Margin,
6650            vec![AccountBalance::new(
6651                Money::from("10000 USD"),
6652                Money::from("0 USD"),
6653                Money::from("10000 USD"),
6654            )],
6655            vec![],
6656            true,
6657            UUID4::new(),
6658            UnixNanos::default(),
6659            UnixNanos::default(),
6660            Some(Currency::USD()),
6661        );
6662        let account = AccountAny::Margin(MarginAccount::new(account_state, true));
6663        cache.borrow_mut().add_account(account).unwrap();
6664        let clock = Rc::new(RefCell::new(VirtualClock::new()));
6665        let mut engine = ExecutionEngine::new(clock, cache.clone(), None);
6666        let mut fills = Vec::new();
6667
6668        for (trade_id, quantity, price, commission) in [
6669            ("T-PARTIAL-1", "0.00002", "56730.0", "0.17 USD"),
6670            ("T-PARTIAL-2", "0.00003", "56731.0", "0.29 USD"),
6671            ("T-PARTIAL-LATE", "0.00001", "56732.0", "0.11 USD"),
6672        ] {
6673            let mut fill = make_fill_report_with_qty(
6674                Some(cid.as_str()),
6675                "100",
6676                trade_id,
6677                Quantity::from(quantity),
6678            );
6679            fill.last_px = Price::from(price);
6680            fill.commission = Money::from(commission);
6681            fills.push(fill);
6682        }
6683
6684        let mut rejection = make_status_report(Some(cid.as_str()), "100", OrderStatus::Rejected);
6685        rejection.filled_qty = Quantity::from(report_filled_qty);
6686
6687        let mut reports: Vec<_> = fills[..fills_before_status]
6688            .iter()
6689            .cloned()
6690            .map(ExecutionReport::Fill)
6691            .collect();
6692        reports.push(ExecutionReport::Order(rejection.clone()));
6693        reports.push(ExecutionReport::Order(rejection.clone()));
6694        for report in reports {
6695            handle_execution_report(
6696                report,
6697                &state,
6698                &emitter,
6699                &ws_client,
6700                &http_client,
6701                &mut pending_cloids,
6702                UnixNanos::default(),
6703            );
6704        }
6705
6706        if let Some(rejected) = post_rejection {
6707            let tasks = TaskGroup::new();
6708
6709            let route = PostRejectionRoute::new(
6710                &emitter,
6711                &ws_client,
6712                &http_client,
6713                state.clone(),
6714                tasks.spawner().unwrap(),
6715            );
6716
6717            if rejected {
6718                let closed = route.emit_once(
6719                    &order,
6720                    "Order rejected by exchange",
6721                    UnixNanos::default(),
6722                    &cloid_for(cid.as_str()),
6723                );
6724                assert_eq!(closed, fills_before_status == 2);
6725            } else {
6726                route.resolve_without_post_rejection(
6727                    &order,
6728                    UnixNanos::default(),
6729                    &cloid_for(cid.as_str()),
6730                );
6731            }
6732        }
6733
6734        for fill in fills[fills_before_status..2]
6735            .iter()
6736            .flat_map(|fill| [fill, fill])
6737        {
6738            handle_execution_report(
6739                ExecutionReport::Fill(fill.clone()),
6740                &state,
6741                &emitter,
6742                &ws_client,
6743                &http_client,
6744                &mut pending_cloids,
6745                UnixNanos::default(),
6746            );
6747        }
6748
6749        if fills_before_status < 2 {
6750            let released = tokio::time::timeout(
6751                std::time::Duration::from_secs(1),
6752                state.recv_released_cancels(),
6753            )
6754            .await
6755            .unwrap();
6756            assert_eq!(released.len(), 1);
6757
6758            for report in released {
6759                assert_eq!(report.order_status, OrderStatus::Canceled);
6760                assert_eq!(report.filled_qty, Quantity::from("0.00005"));
6761                handle_execution_report(
6762                    ExecutionReport::Order(report),
6763                    &state,
6764                    &emitter,
6765                    &ws_client,
6766                    &http_client,
6767                    &mut pending_cloids,
6768                    UnixNanos::default(),
6769                );
6770            }
6771        }
6772
6773        let mut replay = rejection;
6774        replay.client_order_id = Some(ClientOrderId::new(cloid_for(cid.as_str()).as_str()));
6775        let (skipped, _) = handle_execution_report(
6776            ExecutionReport::Order(replay),
6777            &state,
6778            &emitter,
6779            &ws_client,
6780            &http_client,
6781            &mut pending_cloids,
6782            UnixNanos::default(),
6783        );
6784        assert!(skipped);
6785        let mut late = fills[2].clone();
6786        late.client_order_id = None;
6787
6788        for _ in 0..2 {
6789            handle_execution_report(
6790                ExecutionReport::Fill(late.clone()),
6791                &state,
6792                &emitter,
6793                &ws_client,
6794                &http_client,
6795                &mut pending_cloids,
6796                UnixNanos::default(),
6797            );
6798        }
6799
6800        let events = drain_events(&mut rx);
6801        let mut terminal_count = 0;
6802
6803        for event in events {
6804            match event {
6805                ExecutionEvent::Order(event) => {
6806                    assert!(!matches!(event, OrderEventAny::Rejected(_)));
6807                    terminal_count += usize::from(matches!(event, OrderEventAny::Canceled(_)));
6808                    engine.process(&event);
6809                }
6810                ExecutionEvent::Report(report) => engine.reconcile_execution_report(&report),
6811                other => panic!("unexpected event: {other:?}"),
6812            }
6813        }
6814
6815        let cache = cache.borrow();
6816        let order = cache.order(&cid).unwrap();
6817        let positions = cache.positions(None, None, None, None, None);
6818        assert_eq!(terminal_count, 1);
6819        assert_eq!(order.status(), OrderStatus::Canceled);
6820        assert_eq!(order.venue_order_id(), Some(VenueOrderId::new("100")));
6821        assert_eq!(order.quantity(), Quantity::from("0.0001"));
6822        assert_eq!(order.filled_qty(), Quantity::from("0.00006"));
6823        assert_eq!(order.leaves_qty(), Quantity::from("0.00004"));
6824        assert_eq!(
6825            order.trade_ids(),
6826            fills.iter().map(|fill| &fill.trade_id).collect::<Vec<_>>()
6827        );
6828        assert_eq!(
6829            order.commissions().values().copied().collect::<Vec<_>>(),
6830            vec![Money::from("0.57 USD")]
6831        );
6832        assert_eq!(positions.len(), 1);
6833        assert_fills_preserved(&order, &context, &fills, positions[0].id);
6834        assert_eq!(positions[0].quantity, Quantity::from("0.00006"));
6835        assert_eq!(positions[0].commissions(), vec![Money::from("0.57 USD")]);
6836        assert_eq!(
6837            positions[0].trade_ids(),
6838            fills.iter().map(|fill| fill.trade_id).collect::<Vec<_>>()
6839        );
6840        assert!(state.lookup_context(&cid).is_none());
6841        assert_eq!(state.previous_filled_qty(&cid), None);
6842        assert_eq!(ws_client.get_cloid_mapping(&cloid_for(cid.as_str())), None);
6843    }
6844
6845    fn assert_fills_preserved(
6846        order: &OrderAny,
6847        context: &OrderContext,
6848        reports: &[FillReport],
6849        position_id: PositionId,
6850    ) {
6851        let applied_fills: Vec<_> = order
6852            .events()
6853            .into_iter()
6854            .filter_map(|event| match event {
6855                OrderEventAny::Filled(fill) => Some(fill),
6856                _ => None,
6857            })
6858            .collect();
6859
6860        assert_eq!(applied_fills.len(), reports.len());
6861
6862        for (applied, reported) in applied_fills.iter().zip(reports) {
6863            assert_eq!(applied.client_order_id, context.identity.client_order_id);
6864            assert_eq!(applied.strategy_id, context.identity.strategy_id);
6865            assert_eq!(applied.instrument_id, reported.instrument_id);
6866            assert_eq!(applied.venue_order_id, reported.venue_order_id);
6867            assert_eq!(applied.account_id, reported.account_id);
6868            assert_eq!(applied.trade_id, reported.trade_id);
6869            assert_eq!(applied.order_side, reported.order_side);
6870            assert_eq!(applied.order_type, context.identity.order_type);
6871            assert_eq!(applied.last_qty, reported.last_qty);
6872            assert_eq!(applied.last_px, reported.last_px);
6873            assert_eq!(applied.commission, Some(reported.commission));
6874            assert_eq!(applied.liquidity_side, reported.liquidity_side);
6875            assert_eq!(applied.position_id, Some(position_id));
6876            assert_eq!(applied.ts_event, reported.ts_event);
6877        }
6878    }
6879
6880    #[rstest]
6881    #[case::weaker_duplicate("0.00005", "0", true)]
6882    #[case::stronger_duplicate("0", "0.00005", false)]
6883    fn test_submission_rejection_retains_reported_fills(
6884        #[case] first_qty: &str,
6885        #[case] second_qty: &str,
6886        #[case] retain_first: bool,
6887    ) {
6888        let (emitter, mut rx) = test_emitter();
6889        let state = WsDispatchState::new();
6890        let cid = ClientOrderId::new("O-PENDING-REJECTION");
6891        state.register_context(test_context(cid));
6892        state.mark_submission_pending(cid);
6893        let mut first = make_status_report(Some(cid.as_str()), "100", OrderStatus::Rejected);
6894        first.filled_qty = Quantity::from(first_qty);
6895        let mut second = first.clone();
6896        second.filled_qty = Quantity::from(second_qty);
6897        for report in [&first, &second] {
6898            assert_eq!(
6899                super::dispatch_order_event(report, &state, &emitter, UnixNanos::default()),
6900                super::DispatchOutcome::Skip
6901            );
6902        }
6903
6904        let resolved = state.resolve_submission(&cid);
6905
6906        let expected = if retain_first { first } else { second };
6907        assert_eq!(resolved, Some(expected));
6908        assert!(drain_events(&mut rx).is_empty());
6909    }
6910
6911    #[rstest]
6912    fn test_partial_rejection_keeps_stronger_fill_evidence() {
6913        let (emitter, mut rx) = test_emitter();
6914        let state = WsDispatchState::new();
6915        let cid = ClientOrderId::new("O-PARTIAL-REPLAY");
6916        state.register_context(test_context(cid));
6917        let mut rejection = make_status_report(Some(cid.as_str()), "100", OrderStatus::Rejected);
6918        rejection.filled_qty = Quantity::from("0.00005");
6919        super::dispatch_order_event(&rejection, &state, &emitter, UnixNanos::default());
6920        super::dispatch_order_fill(
6921            &make_fill_report_with_qty(
6922                Some(cid.as_str()),
6923                "100",
6924                "T-FIRST",
6925                Quantity::from("0.00002"),
6926            ),
6927            &state,
6928            &emitter,
6929            UnixNanos::default(),
6930        );
6931        rejection.filled_qty = Quantity::from("0.00001");
6932        let outcome =
6933            super::dispatch_order_event(&rejection, &state, &emitter, UnixNanos::default());
6934        let events = drain_events(&mut rx);
6935        assert_eq!(outcome, super::DispatchOutcome::Skip);
6936        assert_eq!(state.lookup_context(&cid), Some(test_context(cid)));
6937        assert!(matches!(
6938            events.as_slice(),
6939            [
6940                ExecutionEvent::Order(OrderEventAny::Accepted(_)),
6941                ExecutionEvent::Order(OrderEventAny::Filled(_))
6942            ]
6943        ));
6944        assert!(futures_util::FutureExt::now_or_never(state.recv_released_cancels()).is_none());
6945    }
6946
6947    #[rstest]
6948    fn test_full_fill_after_rejection_finishes_filled() {
6949        let (emitter, mut rx) = test_emitter();
6950        let state = WsDispatchState::new();
6951        let cid = ClientOrderId::new("O-FULL-REJECTION");
6952        state.register_context(test_context(cid));
6953        let mut rejection = make_status_report(Some(cid.as_str()), "100", OrderStatus::Rejected);
6954        rejection.filled_qty = Quantity::from("0.0001");
6955        super::dispatch_order_event(&rejection, &state, &emitter, UnixNanos::default());
6956        super::dispatch_order_fill(
6957            &make_fill_report(Some(cid.as_str()), "100", "T-FULL"),
6958            &state,
6959            &emitter,
6960            UnixNanos::default(),
6961        );
6962        let replay =
6963            super::dispatch_order_event(&rejection, &state, &emitter, UnixNanos::default());
6964        let events = drain_events(&mut rx);
6965
6966        let [
6967            ExecutionEvent::Order(OrderEventAny::Accepted(_)),
6968            ExecutionEvent::Order(OrderEventAny::Filled(fill)),
6969        ] = events.as_slice()
6970        else {
6971            panic!("expected acceptance and full fill: {events:?}")
6972        };
6973
6974        assert_eq!(fill.last_qty, Quantity::from("0.0001"));
6975        assert_eq!(fill.trade_id, TradeId::new("T-FULL"));
6976        assert_eq!(replay, super::DispatchOutcome::Skip);
6977        assert_eq!(state.lookup_context(&cid), None);
6978        assert!(futures_util::FutureExt::now_or_never(state.recv_released_cancels()).is_none());
6979    }
6980
6981    #[rstest]
6982    fn test_partial_rejection_waits_for_its_venue_leg_fills() {
6983        let (emitter, mut rx) = test_emitter();
6984        let state = WsDispatchState::new();
6985        let cid = ClientOrderId::new("O-PARTIAL-LEG");
6986        state.register_context(test_context(cid));
6987        super::dispatch_order_fill(
6988            &make_fill_report_with_qty(
6989                Some(cid.as_str()),
6990                "100",
6991                "T-OLD",
6992                Quantity::from("0.00004"),
6993            ),
6994            &state,
6995            &emitter,
6996            UnixNanos::default(),
6997        );
6998        state.record_venue_order_id(cid, VenueOrderId::new("101"));
6999        let mut rejection = make_status_report(Some(cid.as_str()), "101", OrderStatus::Rejected);
7000        rejection.filled_qty = Quantity::from("0.00002");
7001        let outcome =
7002            super::dispatch_order_event(&rejection, &state, &emitter, UnixNanos::default());
7003        super::dispatch_order_fill(
7004            &make_fill_report_with_qty(
7005                Some(cid.as_str()),
7006                "100",
7007                "T-OLD-LATE",
7008                Quantity::from("0.00001"),
7009            ),
7010            &state,
7011            &emitter,
7012            UnixNanos::default(),
7013        );
7014        let events = drain_events(&mut rx);
7015        assert_eq!(outcome, super::DispatchOutcome::Skip);
7016        assert_eq!(state.lookup_context(&cid), Some(test_context(cid)));
7017        assert!(events.iter().all(|event| !matches!(
7018            event,
7019            ExecutionEvent::Order(OrderEventAny::Canceled(_) | OrderEventAny::Rejected(_))
7020        )));
7021        assert_eq!(
7022            state.previous_filled_qty(&cid),
7023            Some(Quantity::from("0.00005"))
7024        );
7025        let pending = state.recv_released_cancels();
7026        assert!(futures_util::FutureExt::now_or_never(pending).is_none());
7027    }
7028
7029    #[rstest]
7030    #[case::status_before_fill(false, true)]
7031    #[case::fill_before_status(true, true)]
7032    #[case::dispatch_fill_evidence(true, false)]
7033    #[tokio::test]
7034    async fn test_partial_rejection_preserves_staged_children_until_fill(
7035        #[case] fill_before_post: bool,
7036        #[case] report_has_fills: bool,
7037    ) {
7038        let ws_client = make_ws_client();
7039        let http_client = make_http_client();
7040        let (emitter, mut rx) = test_emitter();
7041        let state = Arc::new(WsDispatchState::new());
7042        let cid = ClientOrderId::new("O-PARTIAL-PARENT");
7043        let order = limit_order_with_flags(cid.as_str(), false, false);
7044        state.register_context(OrderContext::from(&order));
7045        state.mark_submission_pending(cid);
7046        let mut rejection = make_status_report(Some(cid.as_str()), "100", OrderStatus::Rejected);
7047        if report_has_fills {
7048            rejection.filled_qty = Quantity::from("0.00002");
7049        }
7050
7051        let mut pending_cloids = FifoCache::new();
7052
7053        let (skipped, _) = if report_has_fills {
7054            handle_execution_report(
7055                ExecutionReport::Order(rejection),
7056                &state,
7057                &emitter,
7058                &ws_client,
7059                &http_client,
7060                &mut pending_cloids,
7061                UnixNanos::default(),
7062            )
7063        } else {
7064            (false, None)
7065        };
7066
7067        let brackets = Arc::new(parking_lot::Mutex::new(StagedBracketState::default()));
7068        brackets.lock().stage(
7069            cid,
7070            vec![
7071                staged_child("O-TP-PARTIAL", "O-SL-PARTIAL"),
7072                staged_child("O-SL-PARTIAL", "O-TP-PARTIAL"),
7073            ],
7074        );
7075        let tasks = TaskGroup::new();
7076        let route = PostRejectionRoute::with_staged_brackets(
7077            &emitter,
7078            &ws_client,
7079            &http_client,
7080            state.clone(),
7081            brackets.clone(),
7082            tasks.spawner().unwrap(),
7083        );
7084        let fill = make_fill_report_with_qty(
7085            Some(cid.as_str()),
7086            "100",
7087            "T-PARENT",
7088            Quantity::from("0.00002"),
7089        );
7090
7091        if fill_before_post {
7092            super::dispatch_order_fill(&fill, &state, &emitter, UnixNanos::default());
7093        }
7094
7095        let closed = route.emit_once(
7096            &order,
7097            "Order rejected by exchange",
7098            UnixNanos::default(),
7099            &cloid_for(cid.as_str()),
7100        );
7101        assert_eq!(skipped, report_has_fills);
7102        assert_eq!(closed, fill_before_post);
7103
7104        if !fill_before_post {
7105            assert!(drain_events(&mut rx).is_empty());
7106            super::dispatch_order_fill(&fill, &state, &emitter, UnixNanos::default());
7107        }
7108
7109        let children = brackets.lock().activate(&cid).unwrap();
7110
7111        let released = if fill_before_post {
7112            Vec::new()
7113        } else {
7114            tokio::time::timeout(
7115                std::time::Duration::from_secs(1),
7116                state.recv_released_cancels(),
7117            )
7118            .await
7119            .unwrap()
7120        };
7121
7122        assert_eq!(
7123            children
7124                .iter()
7125                .map(|child| child.order.client_order_id())
7126                .collect::<Vec<_>>(),
7127            vec![
7128                ClientOrderId::new("O-TP-PARTIAL"),
7129                ClientOrderId::new("O-SL-PARTIAL")
7130            ]
7131        );
7132        assert_eq!(released.len(), usize::from(!fill_before_post));
7133
7134        for report in released {
7135            assert_eq!(report.order_status, OrderStatus::Canceled);
7136            assert_eq!(report.venue_order_id, VenueOrderId::new("100"));
7137        }
7138    }
7139
7140    #[rstest]
7141    #[case::canceled(OrderStatus::Canceled)]
7142    #[case::rejected(OrderStatus::Rejected)]
7143    fn test_handle_execution_report_tracked_terminal_evicts_cloid(#[case] status: OrderStatus) {
7144        let ws_client = make_ws_client();
7145        let (emitter, mut rx) = test_emitter();
7146        let state = WsDispatchState::new();
7147        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7148
7149        let cid = ClientOrderId::from("O-HER-CANCEL");
7150        state.register_context(test_context(cid));
7151        state.insert_accepted(cid);
7152        state.record_venue_order_id(cid, VenueOrderId::new("v-cancel"));
7153
7154        ws_client.cache_cloid_mapping(cloid_for("O-HER-CANCEL"), cid);
7155
7156        let report = make_status_report(Some("O-HER-CANCEL"), "v-cancel", status);
7157        let (terminal_skipped, corrective) = handle_execution_report(
7158            ExecutionReport::Order(report),
7159            &state,
7160            &emitter,
7161            &ws_client,
7162            &make_http_client(),
7163            &mut pending_cloids,
7164            UnixNanos::default(),
7165        );
7166
7167        let events = drain_events(&mut rx);
7168        assert!(!terminal_skipped);
7169        assert!(corrective.is_none());
7170        assert_eq!(events.len(), 1);
7171
7172        match status {
7173            OrderStatus::Canceled => assert!(matches!(
7174                events[0],
7175                ExecutionEvent::Order(OrderEventAny::Canceled(_))
7176            )),
7177            OrderStatus::Rejected => assert!(matches!(
7178                events[0],
7179                ExecutionEvent::Order(OrderEventAny::Rejected(_))
7180            )),
7181            _ => unreachable!(),
7182        }
7183        assert_eq!(
7184            ws_client.get_cloid_mapping(&cloid_for("O-HER-CANCEL")),
7185            None
7186        );
7187        assert!(state.filled_orders.contains(&cid));
7188        assert!(state.lookup_context(&cid).is_none());
7189        assert_eq!(state.cached_venue_order_id(&cid), None);
7190    }
7191
7192    #[rstest]
7193    fn test_post_rejection_preserves_exact_reason_when_ws_rejection_arrives_first() {
7194        let ws_client = make_ws_client();
7195        let (emitter, mut rx) = test_emitter();
7196        let state = Arc::new(WsDispatchState::new());
7197        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7198
7199        let cid = ClientOrderId::from("O-HER-WS-REJ");
7200        state.register_context(test_context(cid));
7201        state.mark_submission_pending(cid);
7202        ws_client.cache_cloid_mapping(cloid_for("O-HER-WS-REJ"), cid);
7203
7204        let report = make_status_report(Some("O-HER-WS-REJ"), "v-rej", OrderStatus::Rejected);
7205        handle_execution_report(
7206            ExecutionReport::Order(report),
7207            &state,
7208            &emitter,
7209            &ws_client,
7210            &make_http_client(),
7211            &mut pending_cloids,
7212            UnixNanos::default(),
7213        );
7214
7215        assert!(drain_events(&mut rx).is_empty());
7216        assert_eq!(
7217            ws_client.get_cloid_mapping(&cloid_for("O-HER-WS-REJ")),
7218            Some(cid),
7219        );
7220
7221        let order = limit_order_with_flags("O-HER-WS-REJ", false, true);
7222        let http_client = make_http_client();
7223        let tasks = TaskGroup::new();
7224        let rejection_route = PostRejectionRoute::new(
7225            &emitter,
7226            &ws_client,
7227            &http_client,
7228            state.clone(),
7229            tasks.spawner().unwrap(),
7230        );
7231        let emitted = rejection_route.emit_once(
7232            &order,
7233            "Post only order would have immediately matched, bbo was 56729.0.",
7234            UnixNanos::default(),
7235            &cloid_for("O-HER-WS-REJ"),
7236        );
7237
7238        let events = drain_events(&mut rx);
7239        let ExecutionEvent::Order(OrderEventAny::Rejected(rejected)) = &events[0] else {
7240            panic!("expected OrderRejected, received {:?}", events[0]);
7241        };
7242        assert!(emitted);
7243        assert_eq!(events.len(), 1);
7244        assert_eq!(
7245            rejected.reason,
7246            "Post only order would have immediately matched, bbo was 56729.0.",
7247        );
7248        assert!(rejected.due_post_only);
7249    }
7250
7251    #[rstest]
7252    fn test_post_rejection_suppresses_late_raw_cloid_reject() {
7253        let ws_client = make_ws_client();
7254        let (emitter, mut rx) = test_emitter();
7255        let state = Arc::new(WsDispatchState::new());
7256        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7257
7258        let cid = ClientOrderId::from("O-HER-POST-REJ");
7259        let cloid = cloid_for("O-HER-POST-REJ");
7260        let order = limit_order_with_flags("O-HER-POST-REJ", false, true);
7261        state.register_context(test_context(cid));
7262        ws_client.cache_cloid_mapping(cloid, cid);
7263
7264        let http_client = make_http_client();
7265        let tasks = TaskGroup::new();
7266        let rejection_route = PostRejectionRoute::new(
7267            &emitter,
7268            &ws_client,
7269            &http_client,
7270            state.clone(),
7271            tasks.spawner().unwrap(),
7272        );
7273        let emitted = rejection_route.emit_once(
7274            &order,
7275            "Post only order would have immediately matched",
7276            UnixNanos::default(),
7277            &cloid,
7278        );
7279
7280        let events = drain_events(&mut rx);
7281        assert!(emitted);
7282        assert_eq!(events.len(), 1);
7283        let ExecutionEvent::Order(OrderEventAny::Rejected(rejected)) = &events[0] else {
7284            panic!("expected OrderRejected, received {:?}", events[0]);
7285        };
7286        assert_eq!(
7287            rejected.reason,
7288            "Post only order would have immediately matched",
7289        );
7290        assert!(rejected.due_post_only);
7291        assert_eq!(ws_client.get_cloid_mapping(&cloid), None);
7292        assert!(state.filled_orders.contains(&cid));
7293        assert!(state.terminal_cloid_seen(&cloid));
7294
7295        let late_reject = make_status_report(Some(cloid.as_str()), "v-rej", OrderStatus::Rejected);
7296        handle_execution_report(
7297            ExecutionReport::Order(late_reject),
7298            &state,
7299            &emitter,
7300            &ws_client,
7301            &make_http_client(),
7302            &mut pending_cloids,
7303            UnixNanos::default(),
7304        );
7305
7306        assert!(drain_events(&mut rx).is_empty());
7307    }
7308
7309    #[rstest]
7310    fn test_handle_execution_report_filled_marker_then_fill_evicts_on_fill() {
7311        // The status-only FILLED marker defers the cloid eviction to the
7312        // pending cache; the matching FillReport emits OrderFilled and then
7313        // evicts the cloid mapping as part of the deferred-cleanup path.
7314        let ws_client = make_ws_client();
7315        let (emitter, mut rx) = test_emitter();
7316        let state = WsDispatchState::new();
7317        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7318
7319        let cid = ClientOrderId::from("O-HER-FILL");
7320        state.register_context(test_context(cid));
7321        state.insert_accepted(cid);
7322        state.record_venue_order_id(cid, VenueOrderId::new("v-fill"));
7323
7324        ws_client.cache_cloid_mapping(cloid_for("O-HER-FILL"), cid);
7325
7326        let status_marker = make_status_report(Some("O-HER-FILL"), "v-fill", OrderStatus::Filled);
7327        handle_execution_report(
7328            ExecutionReport::Order(status_marker),
7329            &state,
7330            &emitter,
7331            &ws_client,
7332            &make_http_client(),
7333            &mut pending_cloids,
7334            UnixNanos::default(),
7335        );
7336
7337        assert!(drain_events(&mut rx).is_empty());
7338        assert_eq!(
7339            ws_client.get_cloid_mapping(&cloid_for("O-HER-FILL")),
7340            Some(cid)
7341        );
7342
7343        let fill = make_fill_report(Some("O-HER-FILL"), "v-fill", "trade-fill");
7344        handle_execution_report(
7345            ExecutionReport::Fill(fill),
7346            &state,
7347            &emitter,
7348            &ws_client,
7349            &make_http_client(),
7350            &mut pending_cloids,
7351            UnixNanos::default(),
7352        );
7353
7354        let events = drain_events(&mut rx);
7355        assert_eq!(events.len(), 1);
7356        assert!(matches!(
7357            events[0],
7358            ExecutionEvent::Order(OrderEventAny::Filled(_))
7359        ));
7360        assert_eq!(ws_client.get_cloid_mapping(&cloid_for("O-HER-FILL")), None);
7361    }
7362
7363    /// GH-4270: when a status-only `FILLED` marker arrives before the
7364    /// replacement fill and the `ACCEPTED(new_voi)` is dropped, the fill itself
7365    /// promotes the binding (OrderUpdated then OrderFilled) and, being terminal
7366    /// and no longer buffered, completes the deferred cloid eviction.
7367    #[rstest]
7368    fn test_handle_execution_report_fill_under_filled_marker_promotes_and_evicts_cloid() {
7369        let ws_client = make_ws_client();
7370        let (emitter, mut rx) = test_emitter();
7371        let state = WsDispatchState::new();
7372        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7373
7374        let cid = ClientOrderId::from("O-HER-BUF");
7375        state.register_context(test_context(cid));
7376        state.insert_accepted(cid);
7377        state.record_venue_order_id(cid, VenueOrderId::new("old-voi"));
7378        state.mark_pending_modify(
7379            cid,
7380            VenueOrderId::new("old-voi"),
7381            test_context(cid).quantity,
7382        );
7383
7384        ws_client.cache_cloid_mapping(cloid_for("O-HER-BUF"), cid);
7385
7386        let status_marker = make_status_report(Some("O-HER-BUF"), "new-voi", OrderStatus::Filled);
7387        handle_execution_report(
7388            ExecutionReport::Order(status_marker),
7389            &state,
7390            &emitter,
7391            &ws_client,
7392            &make_http_client(),
7393            &mut pending_cloids,
7394            UnixNanos::default(),
7395        );
7396        assert!(pending_cloids.contains(&cid));
7397        assert_eq!(
7398            ws_client.get_cloid_mapping(&cloid_for("O-HER-BUF")),
7399            Some(cid)
7400        );
7401
7402        let fill = make_fill_report(Some("O-HER-BUF"), "new-voi", "trade-buf");
7403        handle_execution_report(
7404            ExecutionReport::Fill(fill),
7405            &state,
7406            &emitter,
7407            &ws_client,
7408            &make_http_client(),
7409            &mut pending_cloids,
7410            UnixNanos::default(),
7411        );
7412
7413        let events = drain_events(&mut rx);
7414        assert_eq!(events.len(), 2);
7415        assert!(matches!(
7416            events[0],
7417            ExecutionEvent::Order(OrderEventAny::Updated(_))
7418        ));
7419        assert!(matches!(
7420            events[1],
7421            ExecutionEvent::Order(OrderEventAny::Filled(_))
7422        ));
7423        assert_eq!(state.buffered_fill_count(&cid), 0);
7424        assert!(
7425            !pending_cloids.contains(&cid),
7426            "deferred cleanup must complete once the promoting fill lands",
7427        );
7428        assert_eq!(
7429            ws_client.get_cloid_mapping(&cloid_for("O-HER-BUF")),
7430            None,
7431            "cloid mapping must be evicted after the terminal fill",
7432        );
7433    }
7434
7435    /// After a partial fill, the cancel-replace `OrderUpdated` must carry
7436    /// the user's absolute total, not the venue's remaining-only view.
7437    #[rstest]
7438    fn test_cancel_replace_emits_target_total_quantity() {
7439        let ws_client = make_ws_client();
7440        let (emitter, mut rx) = test_emitter();
7441        let state = WsDispatchState::new();
7442        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7443
7444        let cid = ClientOrderId::from("O-HER-CR-QTY");
7445        let target_total = Quantity::from("0.00020");
7446        let venue_remaining = Quantity::from("0.00015");
7447
7448        let mut context = test_context(cid);
7449        context.quantity = target_total;
7450        state.register_context(context);
7451        state.insert_accepted(cid);
7452        state.record_venue_order_id(cid, VenueOrderId::new("old-voi"));
7453        state.mark_pending_modify(cid, VenueOrderId::new("old-voi"), target_total);
7454
7455        ws_client.cache_cloid_mapping(cloid_for("O-HER-CR-QTY"), cid);
7456
7457        let accepted = make_status_report_with_quantity(
7458            Some("O-HER-CR-QTY"),
7459            "new-voi",
7460            OrderStatus::Accepted,
7461            venue_remaining,
7462        );
7463        handle_execution_report(
7464            ExecutionReport::Order(accepted),
7465            &state,
7466            &emitter,
7467            &ws_client,
7468            &make_http_client(),
7469            &mut pending_cloids,
7470            UnixNanos::default(),
7471        );
7472
7473        let events = drain_events(&mut rx);
7474        assert_eq!(events.len(), 1);
7475        match &events[0] {
7476            ExecutionEvent::Order(OrderEventAny::Updated(updated)) => {
7477                assert_eq!(
7478                    updated.quantity, target_total,
7479                    "OrderUpdated must carry the engine's absolute total quantity",
7480                );
7481                assert_eq!(updated.venue_order_id, Some(VenueOrderId::new("new-voi")));
7482            }
7483            other => panic!("expected OrderUpdated, found {other:?}"),
7484        }
7485
7486        // Terminal-fill detection uses the context's absolute target quantity
7487        let context = state
7488            .lookup_context(&cid)
7489            .expect("context should still be tracked");
7490        assert_eq!(context.quantity, target_total);
7491
7492        assert!(state.pending_modify(&cid).is_none());
7493        assert!(state.pending_modify_target_qty(&cid).is_none());
7494        assert_eq!(
7495            state.cached_venue_order_id(&cid),
7496            Some(VenueOrderId::new("new-voi")),
7497        );
7498    }
7499
7500    /// Without a target-qty marker (e.g. reconcile-driven modifies), the
7501    /// promotion falls back to `report.quantity`.
7502    #[rstest]
7503    fn test_cancel_replace_without_marker_falls_back_to_report_quantity() {
7504        let ws_client = make_ws_client();
7505        let (emitter, mut rx) = test_emitter();
7506        let state = WsDispatchState::new();
7507        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7508
7509        let cid = ClientOrderId::from("O-HER-CR-EXT");
7510        state.register_context(test_context(cid));
7511        state.insert_accepted(cid);
7512        state.record_venue_order_id(cid, VenueOrderId::new("old-voi"));
7513
7514        ws_client.cache_cloid_mapping(cloid_for("O-HER-CR-EXT"), cid);
7515
7516        let report_qty = Quantity::from("0.0005");
7517        let accepted = make_status_report_with_quantity(
7518            Some("O-HER-CR-EXT"),
7519            "new-voi",
7520            OrderStatus::Accepted,
7521            report_qty,
7522        );
7523        handle_execution_report(
7524            ExecutionReport::Order(accepted),
7525            &state,
7526            &emitter,
7527            &ws_client,
7528            &make_http_client(),
7529            &mut pending_cloids,
7530            UnixNanos::default(),
7531        );
7532
7533        let events = drain_events(&mut rx);
7534        assert_eq!(events.len(), 1);
7535        match &events[0] {
7536            ExecutionEvent::Order(OrderEventAny::Updated(updated)) => {
7537                assert_eq!(updated.quantity, report_qty);
7538            }
7539            other => panic!("expected OrderUpdated, found {other:?}"),
7540        }
7541    }
7542
7543    fn limit_request(size: Decimal) -> HyperliquidExchangePlaceOrderRequest {
7544        HyperliquidExchangePlaceOrderRequest {
7545            asset: 0,
7546            is_buy: true,
7547            price: "88.949".parse::<Decimal>().unwrap(),
7548            size,
7549            reduce_only: false,
7550            kind: HyperliquidExchangeOrderKind::Limit {
7551                limit: HyperliquidExchangeLimitParams {
7552                    tif: HyperliquidExchangeTif::Gtc,
7553                },
7554            },
7555            cloid: None,
7556        }
7557    }
7558
7559    /// A partial fill landing mid-modify leaves the cancel-replace replacement
7560    /// oversized (sized at the full target). The promotion must queue a
7561    /// corrective reduce to `target - filled` and re-arm the marker.
7562    #[rstest]
7563    fn test_cancel_replace_queues_corrective_reduce_on_in_flight_fill() {
7564        let ws_client = make_ws_client();
7565        let (emitter, mut rx) = test_emitter();
7566        let state = WsDispatchState::new();
7567        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7568
7569        let cid = ClientOrderId::from("O-HER-4154");
7570        let target_total = Quantity::from("1.000");
7571        let old_voi = "445117664938";
7572        let new_voi = "445117686214";
7573
7574        let mut context = test_context(cid);
7575        context.quantity = target_total;
7576        state.register_context(context);
7577        state.insert_accepted(cid);
7578        state.record_venue_order_id(cid, VenueOrderId::new(old_voi));
7579
7580        state.mark_pending_modify(cid, VenueOrderId::new(old_voi), target_total);
7581        state.stash_modify_request(cid, limit_request(Decimal::from(1)));
7582
7583        state.record_filled_qty(cid, Quantity::from("0.165"));
7584
7585        let accepted = make_status_report_with_quantity(
7586            Some("O-HER-4154"),
7587            new_voi,
7588            OrderStatus::Accepted,
7589            Quantity::from("0.835"),
7590        );
7591        let (_, corrective) = handle_execution_report(
7592            ExecutionReport::Order(accepted),
7593            &state,
7594            &emitter,
7595            &ws_client,
7596            &make_http_client(),
7597            &mut pending_cloids,
7598            UnixNanos::default(),
7599        );
7600
7601        let events = drain_events(&mut rx);
7602        assert_eq!(events.len(), 1);
7603        match &events[0] {
7604            ExecutionEvent::Order(OrderEventAny::Updated(updated)) => {
7605                assert_eq!(updated.quantity, target_total);
7606                assert_eq!(updated.venue_order_id, Some(VenueOrderId::new(new_voi)));
7607            }
7608            other => panic!("expected OrderUpdated, found {other:?}"),
7609        }
7610
7611        let (corr_cid, queued) =
7612            corrective.expect("oversized replacement must queue a corrective reduce");
7613        assert_eq!(corr_cid, cid);
7614        assert_eq!(queued.oid, 445_117_686_214);
7615        assert_eq!(queued.request.size, "0.835".parse::<Decimal>().unwrap());
7616        // Marker re-armed on the new voi so the corrective's own cancel leg
7617        // is suppressed and a further in-flight fill chains another reduce.
7618        assert_eq!(state.pending_modify(&cid), Some(VenueOrderId::new(new_voi)));
7619        assert_eq!(state.pending_modify_target_qty(&cid), Some(target_total));
7620
7621        // The queued generation is the reduce's own marker
7622        state.clear_modify_generation(&cid, queued.generation);
7623        assert!(!state.has_pending_modify(&cid));
7624    }
7625
7626    /// GH-4270: when the replacement ACCEPTED is dropped, a fill on the new leg
7627    /// promotes the binding and (parity with the ACCEPTED path) queues a corrective
7628    /// reduce when an earlier old-leg fill left the replacement oversized.
7629    #[rstest]
7630    fn test_cancel_replace_fill_promotion_queues_corrective_reduce() {
7631        let ws_client = make_ws_client();
7632        let (emitter, mut rx) = test_emitter();
7633        let state = WsDispatchState::new();
7634        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7635
7636        let cid = ClientOrderId::from("O-HER-FILL-CORR");
7637        let target_total = Quantity::from("1.000");
7638        let old_voi = "445117664938";
7639        let new_voi = "445117686214";
7640
7641        let mut context = test_context(cid);
7642        context.quantity = target_total;
7643        state.register_context(context);
7644        state.insert_accepted(cid);
7645        state.record_venue_order_id(cid, VenueOrderId::new(old_voi));
7646        state.mark_pending_modify(cid, VenueOrderId::new(old_voi), target_total);
7647        state.stash_modify_request(cid, limit_request(Decimal::from(1)));
7648        state.record_filled_qty(cid, Quantity::from("0.165"));
7649
7650        let fill = make_fill_report_with_qty(
7651            Some("O-HER-FILL-CORR"),
7652            new_voi,
7653            "T-FILL-CORR",
7654            Quantity::from("0.100"),
7655        );
7656        let (_, corrective) = handle_execution_report(
7657            ExecutionReport::Fill(fill),
7658            &state,
7659            &emitter,
7660            &ws_client,
7661            &make_http_client(),
7662            &mut pending_cloids,
7663            UnixNanos::default(),
7664        );
7665
7666        let events = drain_events(&mut rx);
7667        assert_eq!(events.len(), 2);
7668        assert!(matches!(
7669            events[0],
7670            ExecutionEvent::Order(OrderEventAny::Updated(_))
7671        ));
7672        assert!(matches!(
7673            events[1],
7674            ExecutionEvent::Order(OrderEventAny::Filled(_))
7675        ));
7676
7677        let (corr_cid, queued) =
7678            corrective.expect("oversized replacement must queue a corrective reduce");
7679        assert_eq!(corr_cid, cid);
7680        assert_eq!(queued.oid, 445_117_686_214);
7681        assert_eq!(queued.request.size, "0.735".parse::<Decimal>().unwrap());
7682        assert_eq!(state.pending_modify(&cid), Some(VenueOrderId::new(new_voi)));
7683    }
7684
7685    /// Without an in-flight fill the replacement is correctly sized, so the
7686    /// promotion must not queue a corrective reduce and must clear the marker.
7687    #[rstest]
7688    fn test_cancel_replace_no_corrective_without_in_flight_fill() {
7689        let ws_client = make_ws_client();
7690        let (emitter, mut rx) = test_emitter();
7691        let state = WsDispatchState::new();
7692        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7693
7694        let cid = ClientOrderId::from("O-HER-4154-NOFILL");
7695        let target_total = Quantity::from("1.000");
7696
7697        let mut context = test_context(cid);
7698        context.quantity = target_total;
7699        state.register_context(context);
7700        state.insert_accepted(cid);
7701        state.record_venue_order_id(cid, VenueOrderId::new("445117664938"));
7702        state.mark_pending_modify(cid, VenueOrderId::new("445117664938"), target_total);
7703        state.stash_modify_request(cid, limit_request(Decimal::from(1)));
7704
7705        let accepted = make_status_report_with_quantity(
7706            Some("O-HER-4154-NOFILL"),
7707            "445117686214",
7708            OrderStatus::Accepted,
7709            target_total,
7710        );
7711        let (_, corrective) = handle_execution_report(
7712            ExecutionReport::Order(accepted),
7713            &state,
7714            &emitter,
7715            &ws_client,
7716            &make_http_client(),
7717            &mut pending_cloids,
7718            UnixNanos::default(),
7719        );
7720
7721        let _ = drain_events(&mut rx);
7722        assert!(corrective.is_none());
7723        assert!(state.pending_modify(&cid).is_none());
7724        assert!(state.take_corrective(&cid).is_none());
7725        assert!(state.modify_request(&cid).is_none());
7726    }
7727
7728    /// A fill buffered during the in-flight cancel-replace is drained before
7729    /// the corrective is computed, so the corrective must size from the
7730    /// post-drain cumulative. A pre-drain read would see 0 filled and skip it.
7731    #[rstest]
7732    fn test_cancel_replace_corrective_uses_post_drain_buffered_fill() {
7733        let ws_client = make_ws_client();
7734        let (emitter, mut rx) = test_emitter();
7735        let state = WsDispatchState::new();
7736        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7737
7738        let cid = ClientOrderId::from("O-HER-4154-BUF");
7739        let target_total = Quantity::from("1.000");
7740        let new_voi = "445117686214";
7741
7742        let mut context = test_context(cid);
7743        context.quantity = target_total;
7744        state.register_context(context);
7745        state.insert_accepted(cid);
7746        state.record_venue_order_id(cid, VenueOrderId::new("445117664938"));
7747        state.mark_pending_modify(cid, VenueOrderId::new("445117664938"), target_total);
7748        state.stash_modify_request(cid, limit_request(Decimal::from(1)));
7749
7750        let buffered = make_fill_report_with_qty(
7751            Some("O-HER-4154-BUF"),
7752            new_voi,
7753            "trade-buf-4154",
7754            Quantity::from("0.165"),
7755        );
7756        state.buffer_fill(cid, buffered);
7757
7758        let accepted = make_status_report_with_quantity(
7759            Some("O-HER-4154-BUF"),
7760            new_voi,
7761            OrderStatus::Accepted,
7762            Quantity::from("0.835"),
7763        );
7764        let (_, corrective) = handle_execution_report(
7765            ExecutionReport::Order(accepted),
7766            &state,
7767            &emitter,
7768            &ws_client,
7769            &make_http_client(),
7770            &mut pending_cloids,
7771            UnixNanos::default(),
7772        );
7773
7774        let _ = drain_events(&mut rx);
7775        let (_, queued) =
7776            corrective.expect("buffered fill drained before compute must still queue a corrective");
7777        assert_eq!(queued.request.size, "0.835".parse::<Decimal>().unwrap());
7778    }
7779
7780    /// When an in-flight fill brings cumulative filled to exactly the target,
7781    /// the remaining is zero, so no corrective (a reduce-to-zero is not valid)
7782    /// must be queued and the marker is cleared.
7783    #[rstest]
7784    fn test_cancel_replace_no_corrective_when_filled_equals_target() {
7785        let ws_client = make_ws_client();
7786        let (emitter, mut rx) = test_emitter();
7787        let state = WsDispatchState::new();
7788        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7789
7790        let cid = ClientOrderId::from("O-HER-4154-EXACT");
7791        let target_total = Quantity::from("1.000");
7792
7793        let mut context = test_context(cid);
7794        context.quantity = target_total;
7795        state.register_context(context);
7796        state.insert_accepted(cid);
7797        state.record_venue_order_id(cid, VenueOrderId::new("445117664938"));
7798        state.mark_pending_modify(cid, VenueOrderId::new("445117664938"), target_total);
7799        state.stash_modify_request(cid, limit_request(Decimal::from(1)));
7800        state.record_filled_qty(cid, target_total);
7801
7802        let accepted = make_status_report_with_quantity(
7803            Some("O-HER-4154-EXACT"),
7804            "445117686214",
7805            OrderStatus::Accepted,
7806            target_total,
7807        );
7808        let (_, corrective) = handle_execution_report(
7809            ExecutionReport::Order(accepted),
7810            &state,
7811            &emitter,
7812            &ws_client,
7813            &make_http_client(),
7814            &mut pending_cloids,
7815            UnixNanos::default(),
7816        );
7817
7818        let _ = drain_events(&mut rx);
7819        assert!(corrective.is_none());
7820        assert!(state.pending_modify(&cid).is_none());
7821    }
7822
7823    /// A further in-flight fill during the corrective's own modify chains
7824    /// another reduce: the second promotion sizes from the new cumulative.
7825    #[rstest]
7826    fn test_cancel_replace_chains_second_corrective_reduce() {
7827        let ws_client = make_ws_client();
7828        let (emitter, mut rx) = test_emitter();
7829        let state = WsDispatchState::new();
7830        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7831
7832        let cid = ClientOrderId::from("O-HER-4154-CHAIN");
7833        let target_total = Quantity::from("1.000");
7834        let voi3 = "445117699999";
7835
7836        // State after the first corrective: marker re-armed on the prior
7837        // replacement, stashed request reduced to 0.835, 0.165 already filled.
7838        let mut context = test_context(cid);
7839        context.quantity = target_total;
7840        state.register_context(context);
7841        state.insert_accepted(cid);
7842        state.record_venue_order_id(cid, VenueOrderId::new("445117686214"));
7843        state.mark_pending_modify(cid, VenueOrderId::new("445117686214"), target_total);
7844        state.stash_modify_request(cid, limit_request("0.835".parse::<Decimal>().unwrap()));
7845        state.record_filled_qty(cid, Quantity::from("0.465"));
7846
7847        let accepted = make_status_report_with_quantity(
7848            Some("O-HER-4154-CHAIN"),
7849            voi3,
7850            OrderStatus::Accepted,
7851            Quantity::from("0.535"),
7852        );
7853        let (_, corrective) = handle_execution_report(
7854            ExecutionReport::Order(accepted),
7855            &state,
7856            &emitter,
7857            &ws_client,
7858            &make_http_client(),
7859            &mut pending_cloids,
7860            UnixNanos::default(),
7861        );
7862
7863        let _ = drain_events(&mut rx);
7864        let (_, queued) =
7865            corrective.expect("a further in-flight fill must chain another corrective");
7866        assert_eq!(queued.oid, 445_117_699_999);
7867        assert_eq!(queued.request.size, "0.535".parse::<Decimal>().unwrap());
7868        assert_eq!(state.pending_modify(&cid), Some(VenueOrderId::new(voi3)));
7869    }
7870
7871    #[rstest]
7872    fn test_handle_execution_report_external_terminal_evicts_cloid() {
7873        // External (untracked) terminal reports forward to the engine via
7874        // send_order_status_report and immediately evict the cloid mapping
7875        // so the client does not leak mappings for orders it does not own.
7876        let ws_client = make_ws_client();
7877        let (emitter, mut rx) = test_emitter();
7878        let state = WsDispatchState::new();
7879        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7880
7881        let cid = ClientOrderId::from("O-HER-EXT");
7882        ws_client.cache_cloid_mapping(cloid_for("O-HER-EXT"), cid);
7883
7884        let report = make_status_report(Some("O-HER-EXT"), "v-ext", OrderStatus::Canceled);
7885        handle_execution_report(
7886            ExecutionReport::Order(report),
7887            &state,
7888            &emitter,
7889            &ws_client,
7890            &make_http_client(),
7891            &mut pending_cloids,
7892            UnixNanos::default(),
7893        );
7894
7895        let events = drain_events(&mut rx);
7896        assert_eq!(events.len(), 1);
7897        assert!(
7898            matches!(events[0], ExecutionEvent::Report(_)),
7899            "external terminal report should forward to the engine as a report",
7900        );
7901        assert_eq!(ws_client.get_cloid_mapping(&cloid_for("O-HER-EXT")), None);
7902    }
7903
7904    #[rstest]
7905    fn test_handle_execution_report_open_status_preserves_cloid() {
7906        let ws_client = make_ws_client();
7907        let (emitter, _rx) = test_emitter();
7908        let state = WsDispatchState::new();
7909        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7910
7911        let cid = ClientOrderId::from("O-HER-OPEN");
7912        state.register_context(test_context(cid));
7913        ws_client.cache_cloid_mapping(cloid_for("O-HER-OPEN"), cid);
7914
7915        let report = make_status_report(Some("O-HER-OPEN"), "v-open", OrderStatus::Accepted);
7916        handle_execution_report(
7917            ExecutionReport::Order(report),
7918            &state,
7919            &emitter,
7920            &ws_client,
7921            &make_http_client(),
7922            &mut pending_cloids,
7923            UnixNanos::default(),
7924        );
7925
7926        assert_eq!(
7927            ws_client.get_cloid_mapping(&cloid_for("O-HER-OPEN")),
7928            Some(cid)
7929        );
7930    }
7931
7932    #[rstest]
7933    fn test_handle_execution_report_tracked_accepted_emits_typed_event() {
7934        // A tracked open ACCEPTED must flow through the typed-event path,
7935        // NOT the raw report fallback. Catches a mutation that swaps the
7936        // branch polarity inside `handle_execution_report`.
7937        let ws_client = make_ws_client();
7938        let (emitter, mut rx) = test_emitter();
7939        let state = WsDispatchState::new();
7940        let mut pending_cloids: FifoCache<ClientOrderId, 10_000> = FifoCache::new();
7941
7942        let cid = ClientOrderId::from("O-HER-ACC");
7943        state.register_context(test_context(cid));
7944        ws_client.cache_cloid_mapping(cloid_for("O-HER-ACC"), cid);
7945
7946        let report = make_status_report(Some("O-HER-ACC"), "v-acc", OrderStatus::Accepted);
7947        handle_execution_report(
7948            ExecutionReport::Order(report),
7949            &state,
7950            &emitter,
7951            &ws_client,
7952            &make_http_client(),
7953            &mut pending_cloids,
7954            UnixNanos::default(),
7955        );
7956
7957        let events = drain_events(&mut rx);
7958        assert_eq!(events.len(), 1);
7959        assert!(
7960            matches!(events[0], ExecutionEvent::Order(OrderEventAny::Accepted(_))),
7961            "tracked accepted should route through the typed-event path",
7962        );
7963        assert_eq!(
7964            ws_client.get_cloid_mapping(&cloid_for("O-HER-ACC")),
7965            Some(cid)
7966        );
7967    }
7968
7969    fn outcome_limit_order(id: &str, reduce_only: bool) -> OrderAny {
7970        outcome_limit_order_full(id, reduce_only, false, TimeInForce::Gtc)
7971    }
7972
7973    fn outcome_limit_order_full(
7974        id: &str,
7975        reduce_only: bool,
7976        post_only: bool,
7977        time_in_force: TimeInForce,
7978    ) -> OrderAny {
7979        OrderAny::Limit(LimitOrder::new(
7980            TraderId::from("TESTER-001"),
7981            StrategyId::from("S-001"),
7982            InstrumentId::from("1-YES-OUTCOME.HYPERLIQUID"),
7983            ClientOrderId::from(id),
7984            OrderSide::Buy,
7985            Quantity::from("1"),
7986            Price::from("0.5000"),
7987            time_in_force,
7988            None,
7989            post_only,
7990            reduce_only,
7991            false,
7992            None,
7993            None,
7994            None,
7995            None,
7996            None,
7997            None,
7998            None,
7999            None,
8000            None,
8001            None,
8002            None,
8003            Default::default(),
8004            Default::default(),
8005        ))
8006    }
8007
8008    fn outcome_stop_order(id: &str) -> OrderAny {
8009        OrderAny::StopMarket(StopMarketOrder::new(
8010            TraderId::from("TESTER-001"),
8011            StrategyId::from("S-001"),
8012            InstrumentId::from("1-YES-OUTCOME.HYPERLIQUID"),
8013            ClientOrderId::from(id),
8014            OrderSide::Sell,
8015            Quantity::from("1"),
8016            Price::from("0.4000"),
8017            TriggerType::LastPrice,
8018            TimeInForce::Gtc,
8019            None,
8020            false,
8021            false,
8022            None,
8023            None,
8024            None,
8025            None,
8026            None,
8027            None,
8028            None,
8029            None,
8030            None,
8031            None,
8032            None,
8033            Default::default(),
8034            Default::default(),
8035        ))
8036    }
8037
8038    fn perp_with_unsupported_symbol(id: &str) -> OrderAny {
8039        OrderAny::Limit(LimitOrder::new(
8040            TraderId::from("TESTER-001"),
8041            StrategyId::from("S-001"),
8042            InstrumentId::from("BTC-USD-FOO.HYPERLIQUID"),
8043            ClientOrderId::from(id),
8044            OrderSide::Buy,
8045            Quantity::from("1"),
8046            Price::from("100.0"),
8047            TimeInForce::Gtc,
8048            None,
8049            false,
8050            false,
8051            false,
8052            None,
8053            None,
8054            None,
8055            None,
8056            None,
8057            None,
8058            None,
8059            None,
8060            None,
8061            None,
8062            None,
8063            Default::default(),
8064            Default::default(),
8065        ))
8066    }
8067
8068    #[rstest]
8069    fn test_validate_accepts_perp_limit_order() {
8070        let order = limit_order("O-VAL-PERP", false, None, None, None);
8071        validate_order_for_hyperliquid(&order).unwrap();
8072    }
8073
8074    #[rstest]
8075    #[case::gtc_post_only(true, TimeInForce::Gtc)]
8076    #[case::gtc_taker(false, TimeInForce::Gtc)]
8077    #[case::ioc_post_only(true, TimeInForce::Ioc)]
8078    #[case::ioc_taker(false, TimeInForce::Ioc)]
8079    fn test_validate_accepts_outcome_limit_order(
8080        #[case] post_only: bool,
8081        #[case] time_in_force: TimeInForce,
8082    ) {
8083        let order = outcome_limit_order_full(
8084            "O-VAL-OUTCOME",
8085            /* reduce_only */ false,
8086            post_only,
8087            time_in_force,
8088        );
8089        validate_order_for_hyperliquid(&order).unwrap();
8090    }
8091
8092    #[rstest]
8093    fn test_validate_rejects_outcome_reduce_only() {
8094        let order = outcome_limit_order("O-VAL-RO", true);
8095        let err = validate_order_for_hyperliquid(&order).unwrap_err();
8096        assert!(
8097            err.to_string().contains("Reduce-only is not supported"),
8098            "unexpected error: {err}",
8099        );
8100    }
8101
8102    #[rstest]
8103    fn test_validate_rejects_outcome_trigger_order() {
8104        let order = outcome_stop_order("O-VAL-TRIG");
8105        let err = validate_order_for_hyperliquid(&order).unwrap_err();
8106        assert!(
8107            err.to_string()
8108                .contains("Trigger order types are not supported"),
8109            "unexpected error: {err}",
8110        );
8111    }
8112
8113    #[rstest]
8114    fn test_validate_rejects_unsupported_symbol_suffix() {
8115        let order = perp_with_unsupported_symbol("O-VAL-BAD");
8116        let err = validate_order_for_hyperliquid(&order).unwrap_err();
8117        assert!(
8118            err.to_string()
8119                .contains("Unsupported instrument symbol format"),
8120            "unexpected error: {err}",
8121        );
8122    }
8123
8124    #[rstest]
8125    #[tokio::test]
8126    async fn test_post_command_deadline_before_enqueue_is_not_sent() {
8127        let wallet = PrivateKeySigner::random();
8128        let key = Zeroizing::new(format!("{:#x}", wallet.to_bytes()));
8129        let signer = HyperliquidHttpClient::from_credentials(
8130            &key,
8131            None,
8132            HyperliquidEnvironment::Testnet,
8133            10,
8134            None,
8135        )
8136        .unwrap();
8137        let mut client = HyperliquidWebSocketClient::new(
8138            None,
8139            HyperliquidEnvironment::Testnet,
8140            None,
8141            TransportBackend::default(),
8142            None,
8143        );
8144        client.set_post_timeout(std::time::Duration::ZERO);
8145        let action = HyperliquidExchangeAction::Cancel {
8146            cancels: Vec::new(),
8147            fast: None,
8148        };
8149        let failure = client
8150            .post_action_command(&signer, &action)
8151            .await
8152            .map_err(classify_post_failure)
8153            .unwrap_err();
8154        assert_eq!(failure, CommandFailure::not_sent("timeout"));
8155    }
8156
8157    #[rstest]
8158    #[tokio::test]
8159    #[ignore = "live testnet rejection proof with disposable unfunded signer"]
8160    async fn live_testnet_unfunded_command_rejections() {
8161        let wallet = PrivateKeySigner::random();
8162        let key = Zeroizing::new(format!("{:#x}", wallet.to_bytes()));
8163        let signer = HyperliquidHttpClient::from_credentials(
8164            &key,
8165            None,
8166            HyperliquidEnvironment::Testnet,
8167            10,
8168            None,
8169        )
8170        .unwrap();
8171        let mut client = HyperliquidWebSocketClient::new(
8172            None,
8173            HyperliquidEnvironment::Testnet,
8174            None,
8175            TransportBackend::default(),
8176            None,
8177        );
8178        client.set_post_timeout(std::time::Duration::from_secs(10));
8179        client.connect().await.unwrap();
8180        let actions = [
8181            HyperliquidExchangeAction::Order {
8182                orders: Vec::new(),
8183                grouping: HyperliquidExchangeGrouping::Na,
8184                builder: None,
8185            },
8186            HyperliquidExchangeAction::Cancel {
8187                cancels: vec![HyperliquidExchangeCancelOrderRequest { asset: 0, oid: 0 }],
8188                fast: None,
8189            },
8190        ];
8191        let result = tokio::time::timeout(std::time::Duration::from_secs(30), async {
8192            let mut outcomes = Vec::new();
8193            for action in &actions {
8194                outcomes.push(
8195                    client
8196                        .post_action_command(&signer, action)
8197                        .await
8198                        .map_err(classify_post_failure),
8199                );
8200            }
8201            outcomes
8202        })
8203        .await;
8204        client.disconnect().await.unwrap();
8205        for (index, outcome) in result.unwrap().into_iter().enumerate() {
8206            let failure = outcome.unwrap_err();
8207            let CommandFailure::VenueRejected(reason) = &failure else {
8208                panic!("Expected authoritative venue rejection, found {failure:?}");
8209            };
8210            let address = format!("{:#x}", wallet.address());
8211            assert_eq!(
8212                reason.to_lowercase(),
8213                format!("user or api wallet {address} does not exist."),
8214            );
8215            eprintln!(
8216                "Live action {index}: {}",
8217                reason
8218                    .to_lowercase()
8219                    .replace(&address, "<disposable-signer>")
8220            );
8221
8222            if index == 1 {
8223                let (emitter, mut rx) = test_emitter();
8224                let entry = cancel_entry("O-LIVE-UNFUNDED", false);
8225                let ts = get_atomic_clock_realtime().get_time_ns();
8226                super::emit_cancel_failure(&emitter, &entry, failure.clone(), ts);
8227                let ExecutionEvent::Order(OrderEventAny::CancelRejected(event)) =
8228                    rx.try_recv().unwrap()
8229                else {
8230                    panic!("Expected cancel rejection");
8231                };
8232                assert_eq!(event.reason.as_str(), reason);
8233                assert_eq!(event.trader_id, TraderId::from("TESTER-001"));
8234                assert_eq!(event.strategy_id, entry.strategy_id);
8235                assert_eq!(event.instrument_id, entry.instrument_id);
8236                assert_eq!(event.client_order_id, entry.client_order_id);
8237                assert_eq!(event.venue_order_id, entry.venue_order_id);
8238                assert_eq!(event.account_id, Some(AccountId::from("HYPERLIQUID-001")));
8239                assert_eq!(event.ts_event, ts);
8240                assert!(!event.reconciliation);
8241                assert_eq!(event.causation_id, None);
8242                assert!(rx.try_recv().is_err());
8243            }
8244        }
8245    }
8246
8247    #[rstest]
8248    #[tokio::test]
8249    async fn test_reconnect_recovers_fills_during_account_bootstrap() {
8250        let frames: Value = load_test_data("ws_account_states.json");
8251        let time = frames["perp"]["data"]["clearinghouseState"]["time"]
8252            .as_u64()
8253            .unwrap();
8254        let ts_start = UnixNanos::from_millis(time);
8255        let clock: &'static AtomicTime = Box::leak(Box::new(AtomicTime::new(false, ts_start)));
8256        let app = Router::new()
8257            .route("/info", post(bootstrap_info))
8258            .route("/ws", get(bootstrap_ws))
8259            .with_state(clock);
8260        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
8261        let address = listener.local_addr().unwrap();
8262        let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
8263        let wallet = PrivateKeySigner::random();
8264        let key = Zeroizing::new(format!("{:#x}", wallet.to_bytes()));
8265
8266        let core = ExecutionClientCore::new(
8267            TraderId::from("TESTER-001"),
8268            *HYPERLIQUID_CLIENT_ID,
8269            *HYPERLIQUID_VENUE,
8270            OmsType::Netting,
8271            AccountId::from("HYPERLIQUID-001"),
8272            AccountType::Margin,
8273            None,
8274            Rc::new(RefCell::new(Cache::default())),
8275        );
8276
8277        let config = HyperliquidExecutionClientConfig {
8278            private_key: Some(SecretString::from(key.to_string())),
8279            environment: HyperliquidEnvironment::Testnet,
8280            base_url_http: Some(format!("http://{address}/info")),
8281            base_url_exchange: Some(format!("http://{address}/exchange")),
8282            base_url_ws: Some(format!("ws://{address}/ws")),
8283            max_retries: 0,
8284            ..Default::default()
8285        };
8286
8287        let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
8288        nautilus_common::live::runner::set_exec_event_sender(sender);
8289        let mut client = HyperliquidExecutionClient::new(core, config).unwrap();
8290        client.clock = clock;
8291        let meta: PerpMeta = load_test_data("http_meta_perp_sample.json");
8292        let defs = parse_perp_instruments(&meta, 0).unwrap();
8293        let instrument = create_instrument_from_def(&defs[0], ts_start).unwrap();
8294        client.http_client.cache_instrument(&instrument);
8295        client.ws_client.merge_instruments(&[instrument]);
8296        client.start().unwrap();
8297        client.start_ws_stream().await.unwrap();
8298
8299        let fill = tokio::time::timeout(Duration::from_secs(2), async {
8300            loop {
8301                let event = receiver
8302                    .recv()
8303                    .await
8304                    .expect("execution event channel closed");
8305
8306                if let ExecutionEvent::Report(EngineExecutionReport::Fill(fill)) = event {
8307                    break fill;
8308                }
8309            }
8310        })
8311        .await
8312        .expect("reconnect must recover fills preceding bootstrap completion");
8313
8314        assert_eq!(clock.get_time_ns(), ts_start + BOOTSTRAP_DELAY);
8315        assert_eq!(fill.instrument_id, InstrumentId::from(TEST_INSTRUMENT_ID));
8316        assert_eq!(fill.venue_order_id, VenueOrderId::from("101"));
8317        assert_eq!(fill.last_qty.as_decimal(), Decimal::new(1, 3));
8318        assert_eq!(fill.last_px.as_decimal(), Decimal::from(100_000));
8319        assert_eq!(fill.ts_event, ts_start);
8320        client.disconnect().await.unwrap();
8321        server.abort();
8322    }
8323
8324    async fn bootstrap_info(
8325        State(clock): State<&'static AtomicTime>,
8326        Json(request): Json<Value>,
8327    ) -> Json<Value> {
8328        let frames: Value = load_test_data("ws_account_states.json");
8329
8330        let response = match request["type"].as_str().unwrap_or_default() {
8331            "clearinghouseState" => {
8332                clock.increment_time(BOOTSTRAP_DELAY).unwrap();
8333                frames["perp"]["data"]["clearinghouseState"].clone()
8334            }
8335            "spotClearinghouseState" => frames["spot"]["data"]["spotState"].clone(),
8336            "userAbstraction" => Value::String("disabled".to_owned()),
8337            "userFills" => {
8338                let time = frames["perp"]["data"]["clearinghouseState"]["time"]
8339                    .as_u64()
8340                    .unwrap();
8341                let fill = btc_user_fill(101, "0xabc", time, "0x0000000000000000000000000000000a");
8342                serde_json::to_value(vec![fill]).unwrap()
8343            }
8344            _ => Value::Array(vec![]),
8345        };
8346
8347        Json(response)
8348    }
8349
8350    async fn bootstrap_ws(upgrade: WebSocketUpgrade) -> Response {
8351        upgrade.on_upgrade(|mut socket| async move {
8352            let mut reconnected = false;
8353
8354            while let Some(Ok(Message::Text(text))) = socket.next().await {
8355                let request: Value = serde_json::from_str(&text).unwrap();
8356                if request["method"] != "subscribe" {
8357                    continue;
8358                }
8359
8360                let subscription = &request["subscription"];
8361                let response = json!({
8362                    "channel": "subscriptionResponse",
8363                    "data": { "method": "subscribe", "subscription": subscription },
8364                });
8365                socket
8366                    .send(Message::Text(response.to_string().into()))
8367                    .await
8368                    .unwrap();
8369
8370                if !reconnected && subscription["type"] == "userEvents" {
8371                    reconnected = true;
8372                    socket
8373                        .send(Message::Text(RECONNECTED.into()))
8374                        .await
8375                        .unwrap();
8376                }
8377            }
8378        })
8379    }
8380
8381    #[rstest]
8382    #[case::all(false, false)]
8383    #[case::spot_only(true, false)]
8384    #[case::spot_tracked_order(true, true)]
8385    fn test_reconnect_reports_from_history_returns_missed_events_oldest_first(
8386        #[case] spot_only: bool,
8387        #[case] tracked: bool,
8388    ) {
8389        let mut http_client = make_http_client();
8390        http_client.set_account_id(AccountId::from("HYPERLIQUID-001"));
8391        let meta: PerpMeta = load_test_data("http_meta_perp_sample.json");
8392        let defs = parse_perp_instruments(&meta, 0).unwrap();
8393        http_client
8394            .cache_instrument(&create_instrument_from_def(&defs[0], UnixNanos::default()).unwrap());
8395        let ws_client = make_ws_client();
8396        let dispatch_state = WsDispatchState::new();
8397        let filled_id = ClientOrderId::new("O-RECOVER-001");
8398        let accepted_id = ClientOrderId::new("O-RECOVER-002");
8399        let filled_cloid = Cloid::from_client_order_id(filled_id).to_hex();
8400        let accepted_cloid = Cloid::from_client_order_id(accepted_id).to_hex();
8401        let external_cloid = "0x0000000000000000000000000000000a";
8402        ws_client.cache_cloid_mapping(Ustr::from(&filled_cloid), filled_id);
8403        ws_client.cache_cloid_mapping(Ustr::from(&accepted_cloid), accepted_id);
8404        let start_ms = 1_700_000_000_000;
8405        dispatch_state.check_and_insert_trade(btc_fill_trade_id(1001, "0xa3", start_ms + 10));
8406
8407        let fills = vec![
8408            btc_user_fill(1001, "0xa1", start_ms - 1, &filled_cloid),
8409            btc_user_fill(1001, "0xa2", start_ms + 20, &filled_cloid),
8410            btc_user_fill(1001, "0xa3", start_ms + 10, &filled_cloid),
8411            btc_user_fill(2002, "0xb1", start_ms, external_cloid),
8412        ];
8413        let mut filled_order = btc_order_entry(4004, "filled", start_ms + 30, &filled_cloid);
8414        filled_order.order.sz = Decimal::ZERO;
8415
8416        let orders = vec![
8417            btc_order_entry(1001, "canceled", start_ms + 20, &filled_cloid),
8418            btc_order_entry(3003, "open", start_ms, &accepted_cloid),
8419            filled_order,
8420            btc_order_entry(5005, "canceled", start_ms + 40, external_cloid),
8421            btc_order_entry(6006, "canceled", start_ms - 1, &accepted_cloid),
8422            btc_order_entry(7010, "canceled", start_ms + 50, external_cloid),
8423            btc_order_entry(7009, "canceled", start_ms + 50, external_cloid),
8424            btc_order_entry(7008, "canceled", start_ms + 50, external_cloid),
8425            btc_order_entry(7007, "canceled", start_ms + 50, external_cloid),
8426        ];
8427
8428        if spot_only {
8429            http_client
8430                .set_product_types(vec![HyperliquidProductType::Spot])
8431                .unwrap();
8432        }
8433
8434        if tracked {
8435            dispatch_state.register_context(test_context(filled_id));
8436        }
8437
8438        let reports = reconnect_reports_from_history(
8439            fills,
8440            orders,
8441            UnixNanos::from(start_ms * 1_000_000),
8442            &ws_client,
8443            &http_client,
8444            &dispatch_state,
8445        )
8446        .unwrap();
8447
8448        if spot_only {
8449            assert!(reports.is_empty());
8450            return;
8451        }
8452
8453        let summary: Vec<_> = reports
8454            .iter()
8455            .map(|report| match report {
8456                ExecutionReport::Order(report) => (
8457                    report.ts_last.as_millis(),
8458                    report.venue_order_id,
8459                    report.client_order_id,
8460                    Some(report.order_status),
8461                    None,
8462                ),
8463                ExecutionReport::Fill(report) => (
8464                    report.ts_event.as_millis(),
8465                    report.venue_order_id,
8466                    report.client_order_id,
8467                    None,
8468                    Some(report.trade_id),
8469                ),
8470            })
8471            .collect();
8472
8473        assert_eq!(
8474            summary,
8475            vec![
8476                (
8477                    start_ms,
8478                    VenueOrderId::new("2002"),
8479                    None,
8480                    None,
8481                    Some(btc_fill_trade_id(2002, "0xb1", start_ms)),
8482                ),
8483                (
8484                    start_ms,
8485                    VenueOrderId::new("3003"),
8486                    Some(accepted_id),
8487                    Some(OrderStatus::Accepted),
8488                    None,
8489                ),
8490                (
8491                    start_ms + 20,
8492                    VenueOrderId::new("1001"),
8493                    Some(filled_id),
8494                    None,
8495                    Some(btc_fill_trade_id(1001, "0xa2", start_ms + 20)),
8496                ),
8497                (
8498                    start_ms + 20,
8499                    VenueOrderId::new("1001"),
8500                    Some(filled_id),
8501                    Some(OrderStatus::Canceled),
8502                    None,
8503                ),
8504                (
8505                    start_ms + 40,
8506                    VenueOrderId::new("5005"),
8507                    Some(ClientOrderId::new(external_cloid)),
8508                    Some(OrderStatus::Canceled),
8509                    None,
8510                ),
8511                (
8512                    start_ms + 50,
8513                    VenueOrderId::new("7007"),
8514                    Some(ClientOrderId::new(external_cloid)),
8515                    Some(OrderStatus::Canceled),
8516                    None,
8517                ),
8518                (
8519                    start_ms + 50,
8520                    VenueOrderId::new("7008"),
8521                    Some(ClientOrderId::new(external_cloid)),
8522                    Some(OrderStatus::Canceled),
8523                    None,
8524                ),
8525                (
8526                    start_ms + 50,
8527                    VenueOrderId::new("7009"),
8528                    Some(ClientOrderId::new(external_cloid)),
8529                    Some(OrderStatus::Canceled),
8530                    None,
8531                ),
8532                (
8533                    start_ms + 50,
8534                    VenueOrderId::new("7010"),
8535                    Some(ClientOrderId::new(external_cloid)),
8536                    Some(OrderStatus::Canceled),
8537                    None,
8538                ),
8539            ],
8540        );
8541    }
8542
8543    #[rstest]
8544    fn test_execution_product_scope_reconnect_recovers_spot_reports() {
8545        let mut http_client = make_http_client();
8546        http_client.set_account_id(AccountId::from("HYPERLIQUID-001"));
8547        http_client
8548            .set_product_types(vec![HyperliquidProductType::Spot])
8549            .unwrap();
8550        let ws_client = make_ws_client();
8551        let dispatch_state = WsDispatchState::new();
8552        let cloid = "0x0000000000000000000000000000000a";
8553        let ts = 1_700_000_000_000;
8554        let mut fill = btc_user_fill(101, "0xabc", ts, cloid);
8555        fill.coin = Ustr::from("vntls:TOKEN");
8556        let mut order = btc_order_entry(101, "canceled", ts + 1, cloid);
8557        order.order.coin = fill.coin;
8558        let reports = reconnect_reports_from_history(
8559            vec![fill],
8560            vec![order],
8561            UnixNanos::from(ts * 1_000_000),
8562            &ws_client,
8563            &http_client,
8564            &dispatch_state,
8565        )
8566        .unwrap();
8567
8568        assert_eq!(reports.len(), 2);
8569        assert!(
8570            matches!(&reports[0], ExecutionReport::Fill(report) if report.instrument_id.symbol.as_str().ends_with("-SPOT"))
8571        );
8572        assert!(
8573            matches!(&reports[1], ExecutionReport::Order(report) if report.instrument_id.symbol.as_str().ends_with("-SPOT"))
8574        );
8575    }
8576
8577    #[rstest]
8578    fn test_ts_venue_reads_venue_time_not_receipt_time() {
8579        let mut order = make_status_report(None, "1001", OrderStatus::Accepted);
8580        order.ts_last = UnixNanos::from(1_000);
8581        order.ts_init = UnixNanos::from(9_000);
8582        let mut fill = make_fill_report(None, "1001", "T-1");
8583        fill.ts_event = UnixNanos::from(2_000);
8584        fill.ts_init = UnixNanos::from(9_000);
8585
8586        assert_eq!(
8587            ts_venue(&ExecutionReport::Order(order)),
8588            UnixNanos::from(1_000)
8589        );
8590        assert_eq!(
8591            ts_venue(&ExecutionReport::Fill(fill)),
8592            UnixNanos::from(2_000)
8593        );
8594    }
8595
8596    #[rstest]
8597    #[case::external_modify_chain_filled(
8598        true, Some("100"), vec![],
8599        vec![("100", OrderStatus::Canceled, 1, 2), ("101", OrderStatus::Canceled, 2, 3), ("102", OrderStatus::Filled, 3, 4)],
8600        vec![("101", OrderStatus::Accepted, 2, "0.0001", "0"), ("102", OrderStatus::Accepted, 3, "0.0001", "0"), ("102", OrderStatus::Filled, 4, "0.0001", "0.0001")],
8601        None,
8602    )]
8603    #[case::closed_bound_leg_keeps_pending_modify(
8604        true, Some("100"), vec![("100", "0.0002")],
8605        vec![("100", OrderStatus::Canceled, 1, 2)],
8606        vec![("100", OrderStatus::Canceled, 2, "0.0001", "0")],
8607        Some(("100", "0.0002")),
8608    )]
8609    #[case::failed_replacement_is_no_leg(
8610        true, Some("100"), vec![("100", "0.0002")],
8611        vec![("100", OrderStatus::Canceled, 1, 2), ("101", OrderStatus::Rejected, 2, 2)],
8612        vec![("100", OrderStatus::Canceled, 2, "0.0001", "0")],
8613        Some(("100", "0.0002")),
8614    )]
8615    #[case::open_unseen_replacement_is_its_own_opening(
8616        true, Some("100"), vec![("100", "0.0002")],
8617        vec![("100", OrderStatus::Canceled, 1, 2), ("101", OrderStatus::Accepted, 2, 2)],
8618        vec![("101", OrderStatus::Accepted, 2, "0.0001", "0")],
8619        Some(("100", "0.0002")),
8620    )]
8621    #[case::closed_unseen_replacement_opens_before_its_close(
8622        true, Some("100"), vec![("100", "0.0002")],
8623        vec![("100", OrderStatus::Canceled, 1, 2), ("101", OrderStatus::Canceled, 2, 3)],
8624        vec![("101", OrderStatus::Accepted, 2, "0.0001", "0"), ("101", OrderStatus::Canceled, 3, "0.0001", "0")],
8625        Some(("100", "0.0002")),
8626    )]
8627    #[case::each_unseen_leg_opens_in_turn(
8628        true, Some("100"), vec![("100", "0.0002"), ("100", "0.0003")],
8629        vec![("100", OrderStatus::Canceled, 1, 2), ("101", OrderStatus::Canceled, 2, 3), ("102", OrderStatus::Canceled, 3, 4)],
8630        vec![("101", OrderStatus::Accepted, 2, "0.0001", "0"), ("102", OrderStatus::Accepted, 3, "0.0001", "0"), ("102", OrderStatus::Canceled, 4, "0.0001", "0")],
8631        Some(("100", "0.0002")),
8632    )]
8633    #[case::triggered_unseen_replacement_opens_first(
8634        true, Some("100"), vec![],
8635        vec![("100", OrderStatus::Canceled, 1, 2), ("101", OrderStatus::Triggered, 2, 3)],
8636        vec![("101", OrderStatus::Accepted, 2, "0.0001", "0"), ("101", OrderStatus::Triggered, 3, "0.0001", "0")],
8637        None,
8638    )]
8639    #[case::binding_newer_than_history(
8640        true, Some("102"), vec![],
8641        vec![("100", OrderStatus::Canceled, 1, 2), ("101", OrderStatus::Canceled, 2, 3)],
8642        vec![("101", OrderStatus::Canceled, 3, "0.0001", "0")],
8643        None,
8644    )]
8645    #[case::untracked_order_passes_through(
8646        false, None, vec![],
8647        vec![("100", OrderStatus::Canceled, 1, 2), ("101", OrderStatus::Accepted, 2, 2)],
8648        vec![("100", OrderStatus::Canceled, 2, "0.0001", "0"), ("101", OrderStatus::Accepted, 2, "0.0001", "0")],
8649        None,
8650    )]
8651    fn test_resolve_order_legs(
8652        #[case] tracked: bool,
8653        #[case] bound_venue_order_id: Option<&str>,
8654        #[case] pending_modifies: Vec<(&str, &str)>,
8655        #[case] legs: Vec<(&str, OrderStatus, u64, u64)>,
8656        #[case] expected: Vec<(&str, OrderStatus, u64, &str, &str)>,
8657        #[case] front_modify_after: Option<(&str, &str)>,
8658    ) {
8659        let state = WsDispatchState::new();
8660        let client_order_id = ClientOrderId::new("O-LEGS");
8661
8662        if tracked {
8663            state.register_context(test_context(client_order_id));
8664        }
8665
8666        if let Some(voi) = bound_venue_order_id {
8667            state.record_venue_order_id(client_order_id, VenueOrderId::new(voi));
8668        }
8669
8670        for (old_leg, target) in pending_modifies {
8671            state.mark_pending_modify(
8672                client_order_id,
8673                VenueOrderId::new(old_leg),
8674                Quantity::from(target),
8675            );
8676        }
8677
8678        let reports = legs
8679            .into_iter()
8680            .map(|(voi, status, ts_accepted, ts_last)| {
8681                let mut report = make_status_report(Some("O-LEGS"), voi, status);
8682                report.ts_accepted = UnixNanos::from(ts_accepted);
8683                report.ts_last = UnixNanos::from(ts_last);
8684
8685                if status == OrderStatus::Filled {
8686                    report.filled_qty = report.quantity;
8687                }
8688
8689                report
8690            })
8691            .collect();
8692
8693        let resolved: Vec<(String, OrderStatus, u64, String, String)> =
8694            resolve_order_legs(reports, &state)
8695                .iter()
8696                .map(|report| {
8697                    (
8698                        report.venue_order_id.to_string(),
8699                        report.order_status,
8700                        report.ts_last.as_u64(),
8701                        report.quantity.as_decimal().normalize().to_string(),
8702                        report.filled_qty.as_decimal().normalize().to_string(),
8703                    )
8704                })
8705                .collect();
8706
8707        let expected: Vec<(String, OrderStatus, u64, String, String)> = expected
8708            .into_iter()
8709            .map(|(voi, status, ts_last, quantity, filled_qty)| {
8710                (
8711                    voi.to_string(),
8712                    status,
8713                    ts_last,
8714                    quantity.to_string(),
8715                    filled_qty.to_string(),
8716                )
8717            })
8718            .collect();
8719
8720        let front_modify = state
8721            .pending_modify(&client_order_id)
8722            .zip(state.pending_modify_target_qty(&client_order_id))
8723            .map(|(old_leg, target)| {
8724                (
8725                    old_leg.to_string(),
8726                    target.as_decimal().normalize().to_string(),
8727                )
8728            });
8729
8730        let front_modify_after =
8731            front_modify_after.map(|(old_leg, target)| (old_leg.to_string(), target.to_string()));
8732
8733        assert_eq!(resolved, expected);
8734        assert_eq!(front_modify, front_modify_after);
8735    }
8736
8737    fn btc_user_fill(oid: u64, hash: &str, time: u64, cloid: &str) -> HyperliquidFill {
8738        serde_json::from_value(serde_json::json!({
8739            "coin": "BTC",
8740            "px": "100000.0",
8741            "sz": "0.001",
8742            "side": "B",
8743            "time": time,
8744            "startPosition": "0.0",
8745            "dir": "Open Long",
8746            "closedPnl": "0.0",
8747            "hash": hash,
8748            "oid": oid,
8749            "crossed": false,
8750            "fee": "0.04",
8751            "tid": 1,
8752            "feeToken": "USDC",
8753            "cloid": cloid,
8754        }))
8755        .unwrap()
8756    }
8757
8758    fn btc_order_entry(
8759        oid: u64,
8760        status: &str,
8761        status_timestamp: u64,
8762        cloid: &str,
8763    ) -> HyperliquidOrderStatusEntry {
8764        serde_json::from_value(serde_json::json!({
8765            "order": {
8766                "coin": "BTC",
8767                "side": "B",
8768                "limitPx": "100000.0",
8769                "sz": "0.002",
8770                "oid": oid,
8771                "timestamp": status_timestamp,
8772                "origSz": "0.002",
8773                "reduceOnly": false,
8774                "orderType": "Limit",
8775                "tif": "Gtc",
8776                "cloid": cloid,
8777            },
8778            "status": status,
8779            "statusTimestamp": status_timestamp,
8780        }))
8781        .unwrap()
8782    }
8783
8784    fn btc_fill_trade_id(oid: u64, hash: &str, time: u64) -> TradeId {
8785        make_fill_trade_id(
8786            hash,
8787            oid,
8788            rust_decimal_macros::dec!(100000.0),
8789            rust_decimal_macros::dec!(0.001),
8790            time,
8791            rust_decimal_macros::dec!(0.0),
8792        )
8793    }
8794}