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