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