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