1use std::{
74 collections::VecDeque,
75 sync::atomic::{AtomicBool, Ordering},
76};
77
78use ahash::AHashMap;
79use dashmap::{DashMap, DashSet};
80use nautilus_common::cache::fifo::FifoCache;
81use nautilus_core::{UUID4, UnixNanos};
82use nautilus_live::{ExecutionEventEmitter, execution::context::OrderContext};
83use nautilus_model::{
84 enums::{OrderStatus, OrderType},
85 events::{
86 OrderAccepted, OrderCanceled, OrderEventAny, OrderExpired, OrderFilled, OrderRejected,
87 OrderTriggered, OrderUpdated,
88 },
89 identifiers::{AccountId, ClientOrderId, TradeId, VenueOrderId},
90 orders::LIMIT_ORDER_TYPES,
91 reports::{FillReport, OrderStatusReport},
92 types::{Price, Quantity},
93};
94use parking_lot::Mutex;
95use ustr::Ustr;
96
97use crate::{
98 common::consts::HYPERLIQUID_POST_ONLY_WOULD_MATCH,
99 http::models::HyperliquidExchangePlaceOrderRequest,
100};
101
102pub const DEDUP_CAPACITY: usize = 10_000;
103
104pub const MAX_PENDING_MODIFY_INTENTS: usize = 32;
108
109#[derive(Debug, Clone)]
118pub struct ModifyIntent {
119 pub generation: u64,
121 pub old_venue_order_id: Option<VenueOrderId>,
123 pub target_qty: Quantity,
125 pub sent_request: Option<HyperliquidExchangePlaceOrderRequest>,
127}
128
129#[derive(Debug, Clone)]
134pub struct CorrectiveReduce {
135 pub oid: u64,
137 pub generation: u64,
139 pub request: HyperliquidExchangePlaceOrderRequest,
141}
142
143#[derive(Debug, Default)]
150struct ModifyChain {
151 intents: VecDeque<ModifyIntent>,
152 next_generation: u64,
153 held_cancel: Option<OrderStatusReport>,
154}
155
156impl ModifyChain {
157 fn targets(&self, venue_order_id: VenueOrderId) -> bool {
158 self.intents
159 .iter()
160 .any(|intent| intent.old_venue_order_id == Some(venue_order_id))
161 }
162
163 fn release_held_cancel(&mut self) -> Option<OrderStatusReport> {
165 let venue_order_id = self.held_cancel.as_ref()?.venue_order_id;
166
167 if self.targets(venue_order_id) {
168 return None;
169 }
170
171 self.held_cancel.take()
172 }
173}
174
175#[derive(Debug)]
189pub struct WsDispatchState {
190 pub order_contexts: DashMap<ClientOrderId, OrderContext>,
199 pub emitted_accepted: DashSet<ClientOrderId>,
201 emitted_triggered: DashSet<ClientOrderId>,
202 pending_submissions: DashSet<ClientOrderId>,
204 pending_submission_rejections: DashMap<ClientOrderId, OrderStatusReport>,
207 pub filled_orders: DashSet<ClientOrderId>,
212 emitted_trades: Mutex<FifoCache<TradeId, DEDUP_CAPACITY>>,
217 terminal_cloids: Mutex<FifoCache<Ustr, DEDUP_CAPACITY>>,
219 closed_venue_order_ids: Mutex<FifoCache<VenueOrderId, DEDUP_CAPACITY>>,
220 pub cached_venue_order_ids: DashMap<ClientOrderId, VenueOrderId>,
227 pending_modify_chains: DashMap<ClientOrderId, ModifyChain>,
239 pub buffered_fills: DashMap<ClientOrderId, Vec<FillReport>>,
244 pub order_filled_qty: DashMap<ClientOrderId, Quantity>,
247 order_filled_qty_by_venue: Mutex<AHashMap<ClientOrderId, AHashMap<VenueOrderId, Quantity>>>,
248 pending_rejections: Mutex<AHashMap<ClientOrderId, OrderStatusReport>>,
249 pub pending_corrective: DashMap<ClientOrderId, CorrectiveReduce>,
252 released_cancels: Mutex<Vec<OrderStatusReport>>,
253 released_cancel_notify: tokio::sync::Notify,
254 clearing: AtomicBool,
255}
256
257impl Default for WsDispatchState {
258 fn default() -> Self {
259 Self {
260 order_contexts: DashMap::new(),
261 emitted_accepted: DashSet::default(),
262 emitted_triggered: DashSet::default(),
263 pending_submissions: DashSet::default(),
264 pending_submission_rejections: DashMap::new(),
265 filled_orders: DashSet::default(),
266 emitted_trades: Mutex::new(FifoCache::new()),
267 terminal_cloids: Mutex::new(FifoCache::new()),
268 closed_venue_order_ids: Mutex::new(FifoCache::new()),
269 cached_venue_order_ids: DashMap::new(),
270 pending_modify_chains: DashMap::new(),
271 buffered_fills: DashMap::new(),
272 order_filled_qty: DashMap::new(),
273 order_filled_qty_by_venue: Mutex::new(AHashMap::new()),
274 pending_rejections: Mutex::new(AHashMap::new()),
275 pending_corrective: DashMap::new(),
276 released_cancels: Mutex::new(Vec::new()),
277 released_cancel_notify: tokio::sync::Notify::new(),
278 clearing: AtomicBool::new(false),
279 }
280 }
281}
282
283impl WsDispatchState {
284 #[must_use]
286 pub fn new() -> Self {
287 Self::default()
288 }
289
290 pub fn register_context(&self, context: OrderContext) {
293 self.order_contexts
294 .insert(context.identity.client_order_id, context);
295 }
296
297 #[must_use]
299 pub fn lookup_context(&self, client_order_id: &ClientOrderId) -> Option<OrderContext> {
300 self.order_contexts.get(client_order_id).map(|r| *r)
301 }
302
303 pub fn mark_submission_pending(&self, client_order_id: ClientOrderId) {
305 self.pending_submissions.insert(client_order_id);
306 }
307
308 #[must_use]
310 pub fn submission_pending(&self, client_order_id: &ClientOrderId) -> bool {
311 self.pending_submissions.contains(client_order_id)
312 }
313
314 pub fn buffer_submission_rejection(
317 &self,
318 client_order_id: ClientOrderId,
319 report: OrderStatusReport,
320 ) {
321 self.pending_submission_rejections
322 .entry(client_order_id)
323 .and_modify(|pending| retain_rejection_report(pending, &report))
324 .or_insert(report);
325 }
326
327 #[must_use]
329 pub fn resolve_submission(&self, client_order_id: &ClientOrderId) -> Option<OrderStatusReport> {
330 self.pending_submissions.remove(client_order_id);
331 self.pending_submission_rejections
332 .remove(client_order_id)
333 .map(|(_, report)| report)
334 }
335
336 pub fn update_context_price(&self, client_order_id: &ClientOrderId, price: Option<Price>) {
339 if let Some(price) = price
340 && let Some(mut entry) = self.order_contexts.get_mut(client_order_id)
341 {
342 entry.price = Some(price);
343 }
344 }
345
346 pub fn update_context_quantity(&self, client_order_id: &ClientOrderId, quantity: Quantity) {
348 if let Some(mut entry) = self.order_contexts.get_mut(client_order_id) {
349 entry.quantity = quantity;
350 }
351 }
352
353 pub fn insert_accepted(&self, cid: ClientOrderId) {
355 self.evict_if_full(&self.emitted_accepted);
356 self.emitted_accepted.insert(cid);
357 }
358
359 fn insert_triggered(&self, cid: ClientOrderId) -> bool {
361 self.evict_if_full(&self.emitted_triggered);
362 self.emitted_triggered.insert(cid)
363 }
364
365 pub fn insert_filled(&self, cid: ClientOrderId) -> bool {
370 self.evict_if_full(&self.filled_orders);
371 self.filled_orders.insert(cid)
372 }
373
374 pub fn check_and_insert_trade(&self, trade_id: TradeId) -> bool {
379 let mut set = self.emitted_trades.lock();
380 !set.insert(trade_id)
381 }
382
383 #[must_use]
384 pub(crate) fn trade_emitted(&self, trade_id: &TradeId) -> bool {
385 self.emitted_trades.lock().contains(trade_id)
386 }
387
388 pub fn insert_terminal_cloid(&self, cloid: Ustr) {
393 let mut set = self.terminal_cloids.lock();
394 let _ = set.insert(cloid);
395 }
396
397 #[must_use]
399 pub fn terminal_cloid_seen(&self, cloid: &Ustr) -> bool {
400 let set = self.terminal_cloids.lock();
401 set.contains(cloid)
402 }
403
404 pub fn record_venue_order_id(
406 &self,
407 client_order_id: ClientOrderId,
408 venue_order_id: VenueOrderId,
409 ) {
410 self.cached_venue_order_ids
411 .insert(client_order_id, venue_order_id);
412 }
413
414 #[must_use]
416 pub fn cached_venue_order_id(&self, client_order_id: &ClientOrderId) -> Option<VenueOrderId> {
417 self.cached_venue_order_ids.get(client_order_id).map(|r| *r)
418 }
419
420 pub fn mark_pending_modify(
429 &self,
430 client_order_id: ClientOrderId,
431 old_venue_order_id: VenueOrderId,
432 target_qty: Quantity,
433 ) -> u64 {
434 let mut chain = self
435 .pending_modify_chains
436 .entry(client_order_id)
437 .or_default();
438 let generation = chain.next_generation;
439 chain.next_generation += 1;
440 chain.intents.push_back(ModifyIntent {
441 generation,
442 old_venue_order_id: Some(old_venue_order_id),
443 target_qty,
444 sent_request: None,
445 });
446
447 if chain.intents.len() > MAX_PENDING_MODIFY_INTENTS {
448 chain.intents.pop_front();
449 log::warn!(
450 "Modify chain for {client_order_id} exceeded {MAX_PENDING_MODIFY_INTENTS}; \
451 evicting oldest intent",
452 );
453 }
454 generation
455 }
456
457 pub fn clear_pending_modify(&self, client_order_id: &ClientOrderId) {
459 self.pending_modify_chains.remove(client_order_id);
460 }
461
462 pub fn clear_modify_generation(&self, client_order_id: &ClientOrderId, generation: u64) {
472 let Some(mut chain) = self.pending_modify_chains.get_mut(client_order_id) else {
473 return;
474 };
475 let removed_front_old = chain
476 .intents
477 .front()
478 .filter(|front| front.generation == generation)
479 .and_then(|front| front.old_venue_order_id);
480 chain
481 .intents
482 .retain(|intent| intent.generation != generation);
483
484 if let Some(old) = removed_front_old
485 && let Some(new_front) = chain.intents.front_mut()
486 {
487 new_front.old_venue_order_id = Some(old);
488 }
489
490 let released = chain.release_held_cancel();
491 drop(chain);
492 self.pending_modify_chains
495 .remove_if(client_order_id, |_, chain| chain.intents.is_empty());
496
497 if let Some(report) = released {
498 self.release_cancel(client_order_id, report);
499 }
500 }
501
502 pub fn stash_modify_request(
505 &self,
506 client_order_id: ClientOrderId,
507 request: HyperliquidExchangePlaceOrderRequest,
508 ) {
509 if let Some(mut chain) = self.pending_modify_chains.get_mut(&client_order_id)
510 && let Some(back) = chain.intents.back_mut()
511 {
512 back.sent_request = Some(request);
513 } else {
514 log::debug!(
515 "Stash modify request for {client_order_id} with no pending intent; ignoring"
516 );
517 }
518 }
519
520 #[must_use]
522 pub fn modify_request(
523 &self,
524 client_order_id: &ClientOrderId,
525 ) -> Option<HyperliquidExchangePlaceOrderRequest> {
526 self.pending_modify_chains
527 .get(client_order_id)
528 .and_then(|chain| chain.intents.front().and_then(|i| i.sent_request.clone()))
529 }
530
531 pub fn claim_front_modify(
540 &self,
541 client_order_id: &ClientOrderId,
542 new_venue_order_id: VenueOrderId,
543 ) -> Option<ModifyIntent> {
544 let mut chain = self.pending_modify_chains.get_mut(client_order_id)?;
545 let claimed = chain.intents.pop_front();
546 chain.held_cancel = None;
547 if let Some(next) = chain.intents.front_mut() {
548 next.old_venue_order_id = Some(new_venue_order_id);
549 }
550 drop(chain);
551 self.pending_modify_chains
554 .remove_if(client_order_id, |_, chain| chain.intents.is_empty());
555 claimed
556 }
557
558 pub(crate) fn record_closed_venue_order_id(&self, venue_order_id: VenueOrderId) {
559 self.closed_venue_order_ids.lock().add(venue_order_id);
560 }
561
562 pub fn queue_corrective(&self, client_order_id: ClientOrderId, corrective: CorrectiveReduce) {
564 self.pending_corrective.insert(client_order_id, corrective);
565 }
566
567 #[must_use]
569 pub fn take_corrective(&self, client_order_id: &ClientOrderId) -> Option<CorrectiveReduce> {
570 self.pending_corrective
571 .remove(client_order_id)
572 .map(|(_, v)| v)
573 }
574
575 #[must_use]
577 pub fn has_pending_modify(&self, client_order_id: &ClientOrderId) -> bool {
578 self.pending_modify_chains
579 .get(client_order_id)
580 .is_some_and(|chain| !chain.intents.is_empty())
581 }
582
583 #[must_use]
585 pub fn pending_modify(&self, client_order_id: &ClientOrderId) -> Option<VenueOrderId> {
586 self.pending_modify_chains
587 .get(client_order_id)
588 .and_then(|chain| chain.intents.front().and_then(|i| i.old_venue_order_id))
589 }
590
591 #[must_use]
596 pub fn pending_modify_contains_old(
597 &self,
598 client_order_id: &ClientOrderId,
599 venue_order_id: VenueOrderId,
600 ) -> bool {
601 self.pending_modify_chains
602 .get(client_order_id)
603 .is_some_and(|chain| chain.targets(venue_order_id))
604 }
605
606 pub(crate) fn hold_cancel(
610 &self,
611 client_order_id: &ClientOrderId,
612 report: &OrderStatusReport,
613 ) -> bool {
614 let Some(mut chain) = self.pending_modify_chains.get_mut(client_order_id) else {
615 return false;
616 };
617
618 if !chain.targets(report.venue_order_id) {
619 return false;
620 }
621
622 chain.held_cancel = Some(report.clone());
623 true
624 }
625
626 fn release_cancel(&self, client_order_id: &ClientOrderId, report: OrderStatusReport) {
627 log::debug!(
628 "Releasing held terminal report for {} on {client_order_id}: status={:?}",
629 report.venue_order_id,
630 report.order_status,
631 );
632 self.released_cancels.lock().push(report);
633 self.released_cancel_notify.notify_one();
634 }
635
636 pub(crate) async fn recv_released_cancels(&self) -> Vec<OrderStatusReport> {
638 loop {
639 let released = std::mem::take(&mut *self.released_cancels.lock());
640
641 if !released.is_empty() {
642 return released;
643 }
644
645 self.released_cancel_notify.notified().await;
646 }
647 }
648
649 #[must_use]
651 pub fn pending_modify_target_qty(&self, client_order_id: &ClientOrderId) -> Option<Quantity> {
652 self.pending_modify_chains
653 .get(client_order_id)
654 .and_then(|chain| chain.intents.front().map(|i| i.target_qty))
655 }
656
657 pub fn buffer_fill(&self, client_order_id: ClientOrderId, fill: FillReport) {
659 self.buffered_fills
660 .entry(client_order_id)
661 .or_default()
662 .push(fill);
663 }
664
665 #[must_use]
667 pub fn drain_buffered_fills(&self, client_order_id: &ClientOrderId) -> Vec<FillReport> {
668 self.buffered_fills
669 .remove(client_order_id)
670 .map_or_default(|(_, v)| v)
671 }
672
673 #[must_use]
675 pub fn buffered_fill_count(&self, client_order_id: &ClientOrderId) -> usize {
676 self.buffered_fills
677 .get(client_order_id)
678 .map_or(0, |r| r.len())
679 }
680
681 pub fn record_filled_qty(&self, client_order_id: ClientOrderId, qty: Quantity) {
683 self.order_filled_qty.insert(client_order_id, qty);
684 }
685
686 #[must_use]
688 pub fn previous_filled_qty(&self, client_order_id: &ClientOrderId) -> Option<Quantity> {
689 self.order_filled_qty.get(client_order_id).map(|r| *r)
690 }
691
692 pub fn cleanup_terminal(&self, client_order_id: &ClientOrderId) {
697 self.order_contexts.remove(client_order_id);
698 self.emitted_accepted.remove(client_order_id);
699 self.emitted_triggered.remove(client_order_id);
700 self.pending_submissions.remove(client_order_id);
701 self.pending_submission_rejections.remove(client_order_id);
702 self.cached_venue_order_ids.remove(client_order_id);
703 self.pending_modify_chains.remove(client_order_id);
704 self.pending_corrective.remove(client_order_id);
705 self.buffered_fills.remove(client_order_id);
706 self.order_filled_qty.remove(client_order_id);
707 self.order_filled_qty_by_venue
708 .lock()
709 .remove(client_order_id);
710 self.pending_rejections.lock().remove(client_order_id);
711 }
712
713 fn evict_if_full(&self, set: &DashSet<ClientOrderId>) {
714 if set.len() >= DEDUP_CAPACITY
715 && self
716 .clearing
717 .compare_exchange(false, true, Ordering::AcqRel, Ordering::Relaxed)
718 .is_ok()
719 {
720 set.clear();
721 self.clearing.store(false, Ordering::Release);
722 }
723 }
724}
725
726#[derive(Debug, Clone, Copy, PartialEq, Eq)]
728pub enum DispatchOutcome {
729 Tracked,
733 External,
738 Skip,
742}
743
744pub fn dispatch_order_event(
754 report: &OrderStatusReport,
755 state: &WsDispatchState,
756 emitter: &ExecutionEventEmitter,
757 ts_init: UnixNanos,
758) -> DispatchOutcome {
759 let Some(client_order_id) = report.client_order_id else {
760 return DispatchOutcome::External;
761 };
762
763 if state.filled_orders.contains(&client_order_id) {
764 log::debug!(
765 "Skipping stale report for filled order: cid={client_order_id}, status={:?}",
766 report.order_status,
767 );
768 return DispatchOutcome::Skip;
769 }
770
771 let client_order_id_str = client_order_id.as_str();
772 if client_order_id_str.starts_with("0x")
773 && state.terminal_cloid_seen(&Ustr::from(client_order_id_str))
774 {
775 log::debug!(
776 "Skipping stale terminal report for raw cloid: cid={client_order_id}, status={:?}",
777 report.order_status,
778 );
779 return DispatchOutcome::Skip;
780 }
781
782 let Some(context) = state.lookup_context(&client_order_id) else {
783 return DispatchOutcome::External;
784 };
785
786 match report.order_status {
787 OrderStatus::Accepted => {
788 handle_accepted(report, client_order_id, &context, state, emitter, ts_init)
789 }
790 OrderStatus::Triggered => {
791 handle_triggered(report, client_order_id, &context, state, emitter, ts_init)
792 }
793 OrderStatus::Canceled => {
794 handle_canceled(report, client_order_id, &context, state, emitter, ts_init)
795 }
796 OrderStatus::Expired => {
797 handle_expired(report, client_order_id, &context, state, emitter, ts_init)
798 }
799 OrderStatus::Rejected => {
800 handle_rejected(report, client_order_id, &context, state, emitter, ts_init)
801 }
802 OrderStatus::Filled => handle_filled_marker(client_order_id, state),
803 OrderStatus::PartiallyFilled => {
804 DispatchOutcome::Tracked
806 }
807 OrderStatus::PendingUpdate
808 | OrderStatus::PendingCancel
809 | OrderStatus::Submitted
810 | OrderStatus::Initialized
811 | OrderStatus::Denied
812 | OrderStatus::Released
813 | OrderStatus::Emulated
814 | OrderStatus::Voided => DispatchOutcome::Tracked,
815 }
816}
817
818pub fn dispatch_order_fill(
829 report: &FillReport,
830 state: &WsDispatchState,
831 emitter: &ExecutionEventEmitter,
832 ts_init: UnixNanos,
833) -> DispatchOutcome {
834 let Some(client_order_id) = report.client_order_id else {
835 return DispatchOutcome::External;
836 };
837
838 if state.filled_orders.contains(&client_order_id) {
839 return if state.check_and_insert_trade(report.trade_id) {
840 DispatchOutcome::Skip
841 } else {
842 DispatchOutcome::External
843 };
844 }
845
846 let Some(mut context) = state.lookup_context(&client_order_id) else {
847 return DispatchOutcome::External;
848 };
849
850 let mut promoted_corrective: Option<(Quantity, HyperliquidExchangePlaceOrderRequest)> = None;
852
853 if state.has_pending_modify(&client_order_id)
857 && let Some(cached_voi) = state.cached_venue_order_id(&client_order_id)
858 && report.venue_order_id != cached_voi
859 && venue_oid(report.venue_order_id) >= venue_oid(cached_voi)
860 {
861 let target = state.pending_modify_target_qty(&client_order_id);
862 let sent_request = state.modify_request(&client_order_id);
863 let price = sent_request
865 .as_ref()
866 .zip(context.price)
867 .and_then(|(r, cached)| Price::from_decimal_dp(r.price, cached.precision).ok())
868 .or(context.price);
869 let Some(price) = price else {
870 log::warn!(
871 "Cannot promote cancel-replace for {client_order_id} from fill: no target \
872 or cached price; buffering until the replacement ACCEPTED arrives",
873 );
874 state.buffer_fill(client_order_id, report.clone());
875 return DispatchOutcome::Tracked;
876 };
877 let updated_quantity = target.unwrap_or(context.quantity);
878 promote_cancel_replace(
879 client_order_id,
880 &context,
881 state,
882 emitter,
883 report.venue_order_id,
884 report.account_id,
885 price,
886 updated_quantity,
887 None,
888 report.ts_event,
889 ts_init,
890 );
891 context = state.lookup_context(&client_order_id).unwrap_or(context);
893
894 if let (Some(target), Some(sent_request)) = (target, sent_request) {
895 promoted_corrective = Some((target, sent_request));
896 }
897 }
898
899 if state.check_and_insert_trade(report.trade_id) {
900 log::debug!(
901 "Skipping duplicate fill for {client_order_id}: trade_id={}",
902 report.trade_id
903 );
904 return DispatchOutcome::Tracked;
905 }
906
907 let previous = state
908 .previous_filled_qty(&client_order_id)
909 .unwrap_or_else(|| Quantity::zero(report.last_qty.precision));
910 let cumulative = previous + report.last_qty;
911
912 let is_terminal_fill = cumulative >= context.quantity;
913 if is_terminal_fill && !claim_terminal_order(client_order_id, state, OrderStatus::Filled) {
914 return DispatchOutcome::Skip;
915 }
916
917 ensure_accepted_emitted(
918 client_order_id,
919 report.venue_order_id,
920 report.account_id,
921 &context,
922 state,
923 emitter,
924 report.ts_event,
925 ts_init,
926 );
927
928 let filled = OrderFilled::new(
929 emitter.trader_id(),
930 context.identity.strategy_id,
931 context.identity.instrument_id,
932 client_order_id,
933 report.venue_order_id,
934 report.account_id,
935 report.trade_id,
936 context.identity.order_side,
937 context.identity.order_type,
938 report.last_qty,
939 report.last_px,
940 report.commission.currency,
941 report.liquidity_side,
942 UUID4::new(),
943 report.ts_event,
944 ts_init,
945 false,
946 report.venue_position_id,
947 Some(report.commission),
948 None,
949 );
950 emitter.send_order_event(OrderEventAny::Filled(filled));
951
952 state.record_filled_qty(client_order_id, cumulative);
953 {
954 let mut orders = state.order_filled_qty_by_venue.lock();
955 let fills = orders.entry(client_order_id).or_default();
956 let quantity = fills
957 .entry(report.venue_order_id)
958 .or_insert_with(|| Quantity::zero(report.last_qty.precision));
959 *quantity = *quantity + report.last_qty;
960 }
961
962 if let Some((target, sent_request)) = promoted_corrective {
964 maybe_queue_corrective_reduce(
965 state,
966 client_order_id,
967 report.venue_order_id,
968 target,
969 sent_request,
970 );
971 }
972
973 if is_terminal_fill {
974 state.cleanup_terminal(&client_order_id);
975 return DispatchOutcome::Tracked;
976 }
977
978 release_rejection_after_fill(client_order_id, state);
979 DispatchOutcome::Tracked
980}
981
982fn release_rejection_after_fill(client_order_id: ClientOrderId, state: &WsDispatchState) {
983 let mut pending = state.pending_rejections.lock();
984
985 let Some(rejection) = pending.get(&client_order_id) else {
986 return;
987 };
988
989 if filled_qty_for_venue(state, client_order_id, rejection.venue_order_id) < rejection.filled_qty
990 {
991 return;
992 }
993
994 let mut canceled = rejection.clone();
995 pending.remove(&client_order_id);
996 drop(pending);
997 canceled.order_status = OrderStatus::Canceled;
998 state.release_cancel(&client_order_id, canceled);
999}
1000
1001fn handle_accepted(
1002 report: &OrderStatusReport,
1003 client_order_id: ClientOrderId,
1004 context: &OrderContext,
1005 state: &WsDispatchState,
1006 emitter: &ExecutionEventEmitter,
1007 ts_init: UnixNanos,
1008) -> DispatchOutcome {
1009 let venue_order_id = report.venue_order_id;
1010 let ts_event = report.ts_last;
1011 let account_id = report.account_id;
1012
1013 if let Some(cached_voi) = state.cached_venue_order_id(&client_order_id)
1018 && cached_voi != venue_order_id
1019 {
1020 if venue_oid(venue_order_id) < venue_oid(cached_voi) {
1022 log::debug!(
1023 "Skipping ACCEPTED for superseded leg {venue_order_id} on {client_order_id}"
1024 );
1025 return DispatchOutcome::Skip;
1026 }
1027
1028 let price = report.price.or(context.price);
1029 let Some(price) = price else {
1030 log::warn!(
1031 "Cannot emit OrderUpdated for cancel-replace {client_order_id}: \
1032 no price on report and no cached price on context",
1033 );
1034 return DispatchOutcome::Skip;
1035 };
1036
1037 let target_total_qty = state.pending_modify_target_qty(&client_order_id);
1040 let updated_quantity = target_total_qty.unwrap_or(report.quantity);
1041 let sent_request = state.modify_request(&client_order_id);
1042
1043 promote_cancel_replace(
1044 client_order_id,
1045 context,
1046 state,
1047 emitter,
1048 venue_order_id,
1049 account_id,
1050 price,
1051 updated_quantity,
1052 report.trigger_price,
1053 ts_event,
1054 ts_init,
1055 );
1056
1057 if let (Some(target), Some(sent_request)) = (target_total_qty, sent_request) {
1058 maybe_queue_corrective_reduce(
1059 state,
1060 client_order_id,
1061 venue_order_id,
1062 target,
1063 sent_request,
1064 );
1065 }
1066
1067 return DispatchOutcome::Tracked;
1068 }
1069
1070 if state.emitted_accepted.contains(&client_order_id) {
1071 state.update_context_price(&client_order_id, report.price);
1075 return DispatchOutcome::Tracked;
1076 }
1077
1078 state.insert_accepted(client_order_id);
1079 state.record_venue_order_id(client_order_id, venue_order_id);
1080 state.update_context_price(&client_order_id, report.price);
1081
1082 let accepted = OrderAccepted::new(
1083 emitter.trader_id(),
1084 context.identity.strategy_id,
1085 context.identity.instrument_id,
1086 client_order_id,
1087 venue_order_id,
1088 account_id,
1089 UUID4::new(),
1090 ts_event,
1091 ts_init,
1092 false,
1093 );
1094 emitter.send_order_event(OrderEventAny::Accepted(accepted));
1095 DispatchOutcome::Tracked
1096}
1097
1098#[allow(
1101 clippy::too_many_arguments,
1102 reason = "promotion needs the full OrderUpdated field set, sourced from two report shapes"
1103)]
1104fn promote_cancel_replace(
1105 client_order_id: ClientOrderId,
1106 context: &OrderContext,
1107 state: &WsDispatchState,
1108 emitter: &ExecutionEventEmitter,
1109 venue_order_id: VenueOrderId,
1110 account_id: AccountId,
1111 price: Price,
1112 quantity: Quantity,
1113 trigger_price: Option<Price>,
1114 ts_event: UnixNanos,
1115 ts_init: UnixNanos,
1116) {
1117 state.record_venue_order_id(client_order_id, venue_order_id);
1118 state.update_context_quantity(&client_order_id, quantity);
1119 state.update_context_price(&client_order_id, Some(price));
1120 state.claim_front_modify(&client_order_id, venue_order_id);
1122
1123 let updated = OrderUpdated::new(
1124 emitter.trader_id(),
1125 context.identity.strategy_id,
1126 context.identity.instrument_id,
1127 client_order_id,
1128 quantity,
1129 UUID4::new(),
1130 ts_event,
1131 ts_init,
1132 false,
1133 Some(venue_order_id),
1134 Some(account_id),
1135 LIMIT_ORDER_TYPES
1136 .contains(&context.identity.order_type)
1137 .then_some(price),
1138 trigger_price,
1139 None,
1140 false,
1141 );
1142 emitter.send_order_event(OrderEventAny::Updated(updated));
1143
1144 let buffered = state.drain_buffered_fills(&client_order_id);
1147 for fill in buffered {
1148 dispatch_order_fill(&fill, state, emitter, ts_init);
1149 }
1150}
1151
1152pub fn promote_replacement_from_query(
1159 report: &OrderStatusReport,
1160 state: &WsDispatchState,
1161 emitter: &ExecutionEventEmitter,
1162 ts_init: UnixNanos,
1163) -> bool {
1164 if report.order_status != OrderStatus::Accepted {
1165 return false;
1166 }
1167
1168 let Some(client_order_id) = report.client_order_id else {
1169 return false;
1170 };
1171
1172 if !state.has_pending_modify(&client_order_id) {
1173 return false;
1174 }
1175
1176 let Some(cached_voi) = state.cached_venue_order_id(&client_order_id) else {
1177 return false;
1178 };
1179
1180 if report.venue_order_id == cached_voi {
1181 return false;
1182 }
1183
1184 let Some(context) = state.lookup_context(&client_order_id) else {
1185 return false;
1186 };
1187
1188 let Some(price) = report.price.or(context.price) else {
1189 log::warn!(
1190 "Cannot promote cancel-replace from query for {client_order_id}: \
1191 no price on report and no cached price on context",
1192 );
1193 return false;
1194 };
1195
1196 let updated_quantity = state
1198 .pending_modify_target_qty(&client_order_id)
1199 .unwrap_or(report.quantity);
1200
1201 promote_cancel_replace(
1202 client_order_id,
1203 &context,
1204 state,
1205 emitter,
1206 report.venue_order_id,
1207 report.account_id,
1208 price,
1209 updated_quantity,
1210 report.trigger_price,
1211 report.ts_last,
1212 ts_init,
1213 );
1214
1215 log::debug!("Promoted cancel-replace replacement for {client_order_id} from query");
1216
1217 true
1218}
1219
1220fn maybe_queue_corrective_reduce(
1223 state: &WsDispatchState,
1224 client_order_id: ClientOrderId,
1225 venue_order_id: VenueOrderId,
1226 target: Quantity,
1227 sent_request: HyperliquidExchangePlaceOrderRequest,
1228) {
1229 if state
1231 .closed_venue_order_ids
1232 .lock()
1233 .contains(&venue_order_id)
1234 {
1235 return;
1236 }
1237
1238 let Ok(new_oid) = venue_order_id.as_str().parse::<u64>() else {
1239 return;
1240 };
1241
1242 let filled = state
1243 .previous_filled_qty(&client_order_id)
1244 .unwrap_or_else(|| Quantity::zero(target.precision));
1245 if filled >= target {
1246 return;
1247 }
1248
1249 let remaining = (target - filled).as_decimal().normalize();
1250
1251 let sent_size = sent_request.size;
1252 if sent_size > remaining {
1253 let mut corrective = sent_request;
1254 corrective.size = remaining;
1255
1256 let generation = state.mark_pending_modify(client_order_id, venue_order_id, target);
1257 state.stash_modify_request(client_order_id, corrective.clone());
1258 state.queue_corrective(
1259 client_order_id,
1260 CorrectiveReduce {
1261 oid: new_oid,
1262 generation,
1263 request: corrective,
1264 },
1265 );
1266
1267 log::warn!(
1268 "Cancel-replace left {client_order_id} oversized on {venue_order_id} \
1269 (sent {sent_size}, remaining {remaining}); queuing corrective reduce",
1270 );
1271 }
1272}
1273
1274fn handle_triggered(
1275 report: &OrderStatusReport,
1276 client_order_id: ClientOrderId,
1277 context: &OrderContext,
1278 state: &WsDispatchState,
1279 emitter: &ExecutionEventEmitter,
1280 ts_init: UnixNanos,
1281) -> DispatchOutcome {
1282 if !matches!(
1283 context.identity.order_type,
1284 OrderType::StopLimit | OrderType::TrailingStopLimit | OrderType::LimitIfTouched
1285 ) {
1286 log::debug!(
1287 "Ignoring TRIGGERED status for non-triggerable order type {:?}: {client_order_id}",
1288 context.identity.order_type,
1289 );
1290 return DispatchOutcome::Tracked;
1291 }
1292
1293 if !state.insert_triggered(client_order_id) {
1295 log::debug!("Skipping repeated TRIGGERED for {client_order_id}");
1296 return DispatchOutcome::Skip;
1297 }
1298
1299 ensure_accepted_emitted(
1300 client_order_id,
1301 report.venue_order_id,
1302 report.account_id,
1303 context,
1304 state,
1305 emitter,
1306 report.ts_last,
1307 ts_init,
1308 );
1309
1310 let triggered = OrderTriggered::new(
1311 emitter.trader_id(),
1312 context.identity.strategy_id,
1313 context.identity.instrument_id,
1314 client_order_id,
1315 UUID4::new(),
1316 report.ts_last,
1317 ts_init,
1318 false,
1319 Some(report.venue_order_id),
1320 Some(report.account_id),
1321 );
1322 emitter.send_order_event(OrderEventAny::Triggered(triggered));
1323 DispatchOutcome::Tracked
1324}
1325
1326fn handle_canceled(
1327 report: &OrderStatusReport,
1328 client_order_id: ClientOrderId,
1329 context: &OrderContext,
1330 state: &WsDispatchState,
1331 emitter: &ExecutionEventEmitter,
1332 ts_init: UnixNanos,
1333) -> DispatchOutcome {
1334 let venue_order_id = report.venue_order_id;
1335
1336 if let Some(cached_voi) = state.cached_venue_order_id(&client_order_id)
1337 && cached_voi != venue_order_id
1338 {
1339 if !state.has_pending_modify(&client_order_id)
1340 || venue_oid(venue_order_id) <= venue_oid(cached_voi)
1341 {
1342 log::debug!(
1343 "Skipping stale CANCELED for {venue_order_id} (cached {cached_voi}) on {client_order_id}",
1344 );
1345 return DispatchOutcome::Skip;
1346 }
1347
1348 let Some(price) = report.price.or(context.price) else {
1349 log::warn!(
1350 "Cannot promote canceled replacement for {client_order_id}: no report or cached price",
1351 );
1352 return DispatchOutcome::Skip;
1353 };
1354
1355 let quantity = state
1356 .pending_modify_target_qty(&client_order_id)
1357 .unwrap_or(report.quantity);
1358
1359 promote_cancel_replace(
1362 client_order_id,
1363 context,
1364 state,
1365 emitter,
1366 venue_order_id,
1367 report.account_id,
1368 price,
1369 quantity,
1370 report.trigger_price,
1371 report.ts_last,
1372 ts_init,
1373 );
1374 }
1375
1376 if state.hold_cancel(&client_order_id, report) {
1382 log::debug!(
1383 "Holding cancel-before-accept leg for {client_order_id}: venue_order_id={venue_order_id}",
1384 );
1385 return DispatchOutcome::Skip;
1386 }
1387
1388 if !claim_terminal_order(client_order_id, state, report.order_status) {
1389 return DispatchOutcome::Skip;
1390 }
1391
1392 ensure_accepted_emitted(
1393 client_order_id,
1394 venue_order_id,
1395 report.account_id,
1396 context,
1397 state,
1398 emitter,
1399 report.ts_last,
1400 ts_init,
1401 );
1402
1403 let canceled = OrderCanceled::new(
1404 emitter.trader_id(),
1405 context.identity.strategy_id,
1406 context.identity.instrument_id,
1407 client_order_id,
1408 UUID4::new(),
1409 report.ts_last,
1410 ts_init,
1411 false,
1412 Some(venue_order_id),
1413 Some(report.account_id),
1414 None,
1415 );
1416 emitter.send_order_event(OrderEventAny::Canceled(canceled));
1417
1418 state.cleanup_terminal(&client_order_id);
1419 DispatchOutcome::Tracked
1420}
1421
1422fn handle_expired(
1423 report: &OrderStatusReport,
1424 client_order_id: ClientOrderId,
1425 context: &OrderContext,
1426 state: &WsDispatchState,
1427 emitter: &ExecutionEventEmitter,
1428 ts_init: UnixNanos,
1429) -> DispatchOutcome {
1430 if !claim_terminal_order(client_order_id, state, report.order_status) {
1431 return DispatchOutcome::Skip;
1432 }
1433
1434 ensure_accepted_emitted(
1435 client_order_id,
1436 report.venue_order_id,
1437 report.account_id,
1438 context,
1439 state,
1440 emitter,
1441 report.ts_last,
1442 ts_init,
1443 );
1444
1445 let expired = OrderExpired::new(
1446 emitter.trader_id(),
1447 context.identity.strategy_id,
1448 context.identity.instrument_id,
1449 client_order_id,
1450 UUID4::new(),
1451 report.ts_last,
1452 ts_init,
1453 false,
1454 Some(report.venue_order_id),
1455 Some(report.account_id),
1456 );
1457 emitter.send_order_event(OrderEventAny::Expired(expired));
1458 state.cleanup_terminal(&client_order_id);
1459 DispatchOutcome::Tracked
1460}
1461
1462fn handle_rejected(
1463 report: &OrderStatusReport,
1464 client_order_id: ClientOrderId,
1465 context: &OrderContext,
1466 state: &WsDispatchState,
1467 emitter: &ExecutionEventEmitter,
1468 ts_init: UnixNanos,
1469) -> DispatchOutcome {
1470 if state.submission_pending(&client_order_id) {
1471 state.buffer_submission_rejection(client_order_id, report.clone());
1472 return DispatchOutcome::Skip;
1473 }
1474
1475 if let Some(bound) = state.cached_venue_order_id(&client_order_id)
1478 && bound != report.venue_order_id
1479 {
1480 return DispatchOutcome::Skip;
1481 }
1482
1483 {
1484 let mut pending = state.pending_rejections.lock();
1486 if !report.filled_qty.is_zero()
1487 && filled_qty_for_venue(state, client_order_id, report.venue_order_id)
1488 < report.filled_qty
1489 {
1490 pending
1491 .entry(client_order_id)
1492 .and_modify(|pending| retain_rejection_report(pending, report))
1493 .or_insert_with(|| report.clone());
1494 return DispatchOutcome::Skip;
1495 }
1496
1497 if pending.contains_key(&client_order_id) {
1498 return DispatchOutcome::Skip;
1499 }
1500 }
1501
1502 if !report.filled_qty.is_zero()
1503 || state
1504 .previous_filled_qty(&client_order_id)
1505 .is_some_and(|qty| !qty.is_zero())
1506 {
1507 return handle_canceled(report, client_order_id, context, state, emitter, ts_init);
1508 }
1509
1510 if !claim_terminal_order(client_order_id, state, report.order_status) {
1511 return DispatchOutcome::Skip;
1512 }
1513
1514 let reason = report
1515 .cancel_reason
1516 .clone()
1517 .unwrap_or_else(|| "Order rejected by exchange".to_string());
1518 let rejected = OrderRejected::new(
1519 emitter.trader_id(),
1520 context.identity.strategy_id,
1521 context.identity.instrument_id,
1522 client_order_id,
1523 report.account_id,
1524 Ustr::from(&reason),
1525 UUID4::new(),
1526 report.ts_last,
1527 ts_init,
1528 false,
1529 report.post_only && reason.contains(HYPERLIQUID_POST_ONLY_WOULD_MATCH),
1530 );
1531 emitter.send_order_event(OrderEventAny::Rejected(rejected));
1532 state.cleanup_terminal(&client_order_id);
1533 DispatchOutcome::Tracked
1534}
1535
1536fn retain_rejection_report(pending: &mut OrderStatusReport, report: &OrderStatusReport) {
1537 if report.venue_order_id != pending.venue_order_id || report.filled_qty >= pending.filled_qty {
1538 *pending = report.clone();
1539 }
1540}
1541
1542fn filled_qty_for_venue(
1543 state: &WsDispatchState,
1544 client_order_id: ClientOrderId,
1545 venue_order_id: VenueOrderId,
1546) -> Quantity {
1547 state
1548 .order_filled_qty_by_venue
1549 .lock()
1550 .get(&client_order_id)
1551 .and_then(|fills| fills.get(&venue_order_id).copied())
1552 .unwrap_or_else(|| Quantity::zero(0))
1553}
1554
1555fn claim_terminal_order(
1556 client_order_id: ClientOrderId,
1557 state: &WsDispatchState,
1558 status: OrderStatus,
1559) -> bool {
1560 let claimed = state.insert_filled(client_order_id);
1561 if !claimed {
1562 log::debug!("Skipping duplicate terminal event for {client_order_id}: status={status:?}",);
1563 }
1564
1565 claimed
1566}
1567
1568fn handle_filled_marker(
1569 _client_order_id: ClientOrderId,
1570 _state: &WsDispatchState,
1571) -> DispatchOutcome {
1572 DispatchOutcome::Tracked
1580}
1581
1582#[allow(clippy::too_many_arguments)]
1590fn ensure_accepted_emitted(
1591 client_order_id: ClientOrderId,
1592 venue_order_id: VenueOrderId,
1593 account_id: AccountId,
1594 context: &OrderContext,
1595 state: &WsDispatchState,
1596 emitter: &ExecutionEventEmitter,
1597 ts_event: UnixNanos,
1598 ts_init: UnixNanos,
1599) {
1600 if state.emitted_accepted.contains(&client_order_id) {
1601 return;
1602 }
1603 state.insert_accepted(client_order_id);
1604 state.record_venue_order_id(client_order_id, venue_order_id);
1605
1606 let accepted = OrderAccepted::new(
1607 emitter.trader_id(),
1608 context.identity.strategy_id,
1609 context.identity.instrument_id,
1610 client_order_id,
1611 venue_order_id,
1612 account_id,
1613 UUID4::new(),
1614 ts_event,
1615 ts_init,
1616 false,
1617 );
1618 emitter.send_order_event(OrderEventAny::Accepted(accepted));
1619}
1620
1621pub(crate) fn venue_oid(venue_order_id: VenueOrderId) -> u64 {
1623 venue_order_id.as_str().parse().unwrap_or_default()
1624}
1625
1626#[cfg(test)]
1627mod tests {
1628 use std::{sync::Arc, time::Duration};
1629
1630 use futures_util::FutureExt;
1631 use nautilus_common::{messages::ExecutionEvent, testing::wait_until};
1632 use nautilus_core::time::get_atomic_clock_realtime;
1633 use nautilus_live::execution::context::OrderIdentity;
1634 use nautilus_model::{
1635 enums::{AccountType, LiquiditySide, OrderSide, TimeInForce},
1636 identifiers::{ClientOrderId, InstrumentId, StrategyId, TradeId, TraderId},
1637 types::Money,
1638 };
1639 use rstest::rstest;
1640 use rust_decimal::Decimal;
1641
1642 use super::*;
1643 use crate::http::models::{
1644 HyperliquidExchangeLimitParams, HyperliquidExchangeOrderKind, HyperliquidExchangeTif,
1645 };
1646
1647 fn make_context(client_order_id: ClientOrderId) -> OrderContext {
1648 OrderContext {
1649 identity: OrderIdentity {
1650 client_order_id,
1651 strategy_id: StrategyId::from("S-001"),
1652 instrument_id: InstrumentId::from("BTC-USD-PERP.HYPERLIQUID"),
1653 order_side: OrderSide::Buy,
1654 order_type: OrderType::Limit,
1655 },
1656 quantity: Quantity::from("0.0001"),
1657 price: None,
1658 trigger_price: None,
1659 trigger_type: None,
1660 time_in_force: TimeInForce::Gtc,
1661 is_post_only: false,
1662 is_reduce_only: false,
1663 is_quote_quantity: false,
1664 }
1665 }
1666
1667 #[rstest]
1668 fn test_rejection_registers_atomically_with_fill_completion() {
1669 let state = Arc::new(WsDispatchState::new());
1670 let (emitter, mut rx) = test_emitter();
1671 let cid = ClientOrderId::new("O-REJECTION-RACE");
1672 let context = make_context(cid);
1673 state.register_context(context);
1674
1675 let first = FillReport::new(
1676 AccountId::new("HYPERLIQUID-001"),
1677 context.identity.instrument_id,
1678 VenueOrderId::new("100"),
1679 TradeId::new("T-RACE-1"),
1680 OrderSide::Buy,
1681 Quantity::from("0.00003"),
1682 Price::from("56730.0"),
1683 Money::from("0.17 USD"),
1684 LiquiditySide::Taker,
1685 Some(cid),
1686 None,
1687 UnixNanos::default(),
1688 UnixNanos::default(),
1689 None,
1690 );
1691 dispatch_order_fill(&first, &state, &emitter, UnixNanos::default());
1692
1693 let rejection = OrderStatusReport::new(
1694 first.account_id,
1695 first.instrument_id,
1696 Some(cid),
1697 first.venue_order_id,
1698 OrderSide::Buy.into(),
1699 OrderType::Limit,
1700 TimeInForce::Gtc,
1701 OrderStatus::Rejected,
1702 context.quantity,
1703 Quantity::from("0.00005"),
1704 UnixNanos::default(),
1705 UnixNanos::default(),
1706 UnixNanos::default(),
1707 None,
1708 );
1709 let fills = state.order_filled_qty_by_venue.lock();
1710 let reject_state = state.clone();
1711 let reject_emitter = emitter.clone();
1712
1713 let rejected = std::thread::spawn(move || {
1714 dispatch_order_event(
1715 &rejection,
1716 &reject_state,
1717 &reject_emitter,
1718 UnixNanos::default(),
1719 )
1720 });
1721
1722 let timeout = Duration::from_secs(5);
1723 wait_until(|| state.pending_rejections.is_locked(), timeout);
1724 let mut last = first;
1725 last.trade_id = TradeId::new("T-RACE-2");
1726 last.last_qty = Quantity::from("0.00002");
1727 last.commission = Money::from("0.29 USD");
1728 let fill_state = state.clone();
1729 let fill_emitter = emitter.clone();
1730 let filled = std::thread::spawn(move || {
1731 dispatch_order_fill(&last, &fill_state, &fill_emitter, UnixNanos::default())
1732 });
1733
1734 wait_until(
1735 || state.previous_filled_qty(&cid) == Some(Quantity::from("0.00005")),
1736 timeout,
1737 );
1738 drop(fills);
1739 rejected.join().unwrap();
1740 assert_eq!(filled.join().unwrap(), DispatchOutcome::Tracked);
1741
1742 if let Some(released) = state.recv_released_cancels().now_or_never() {
1743 assert_eq!(released.len(), 1);
1744 dispatch_order_event(&released[0], &state, &emitter, UnixNanos::default());
1745 }
1746
1747 let mut events = Vec::new();
1748 while let Ok(event) = rx.try_recv() {
1749 events.push(event);
1750 }
1751
1752 let [
1753 ExecutionEvent::Order(OrderEventAny::Accepted(_)),
1754 ExecutionEvent::Order(OrderEventAny::Filled(first)),
1755 ExecutionEvent::Order(OrderEventAny::Filled(last)),
1756 ExecutionEvent::Order(OrderEventAny::Canceled(_)),
1757 ] = events.as_slice()
1758 else {
1759 panic!("expected two fills followed by cancellation: {events:?}");
1760 };
1761
1762 assert_eq!(first.trade_id, TradeId::new("T-RACE-1"));
1763 assert_eq!(first.last_qty, Quantity::from("0.00003"));
1764 assert_eq!(first.commission, Some(Money::from("0.17 USD")));
1765 assert_eq!(last.trade_id, TradeId::new("T-RACE-2"));
1766 assert_eq!(last.last_qty, Quantity::from("0.00002"));
1767 assert_eq!(last.commission, Some(Money::from("0.29 USD")));
1768 assert_eq!(state.lookup_context(&cid), None);
1769 assert!(state.filled_orders.contains(&cid));
1770 }
1771
1772 #[rstest]
1773 fn test_register_and_lookup_context() {
1774 let state = WsDispatchState::new();
1775 let cid = ClientOrderId::new("O-001");
1776 state.register_context(make_context(cid));
1777
1778 assert_eq!(state.lookup_context(&cid), Some(make_context(cid)));
1779 }
1780
1781 #[rstest]
1782 fn test_lookup_context_missing_returns_none() {
1783 let state = WsDispatchState::new();
1784 let cid = ClientOrderId::new("not-tracked");
1785 assert!(state.lookup_context(&cid).is_none());
1786 }
1787
1788 #[rstest]
1789 fn test_update_context_refreshes_price_and_quantity() {
1790 let state = WsDispatchState::new();
1791 let cid = ClientOrderId::new("O-003");
1792 state.register_context(make_context(cid));
1793
1794 state.update_context_price(&cid, Some(Price::from("56731.5")));
1795 state.update_context_quantity(&cid, Quantity::from("0.0002"));
1796
1797 assert_eq!(
1798 state.lookup_context(&cid),
1799 Some(OrderContext {
1800 price: Some(Price::from("56731.5")),
1801 quantity: Quantity::from("0.0002"),
1802 ..make_context(cid)
1803 }),
1804 );
1805 }
1806
1807 #[rstest]
1808 fn test_update_context_price_without_price_keeps_cached_price() {
1809 let state = WsDispatchState::new();
1810 let cid = ClientOrderId::new("O-004");
1811 let cached = OrderContext {
1812 price: Some(Price::from("56730.0")),
1813 ..make_context(cid)
1814 };
1815 state.register_context(cached);
1816
1817 state.update_context_price(&cid, None);
1818
1819 assert_eq!(state.lookup_context(&cid), Some(cached));
1820 }
1821
1822 #[rstest]
1823 fn test_insert_accepted_dedup() {
1824 let state = WsDispatchState::new();
1825 let cid = ClientOrderId::new("O-002");
1826 assert!(!state.emitted_accepted.contains(&cid));
1827 state.insert_accepted(cid);
1828 assert!(state.emitted_accepted.contains(&cid));
1829 state.insert_accepted(cid);
1830 assert!(state.emitted_accepted.contains(&cid));
1831 }
1832
1833 #[rstest]
1834 fn test_check_and_insert_trade_detects_duplicates() {
1835 let state = WsDispatchState::new();
1836 let trade = TradeId::new("trade-1");
1837 assert!(!state.check_and_insert_trade(trade));
1838 assert!(state.check_and_insert_trade(trade));
1839 }
1840
1841 #[rstest]
1842 fn test_pending_modify_roundtrip() {
1843 let state = WsDispatchState::new();
1844 let cid = ClientOrderId::new("O-010");
1845 let voi = VenueOrderId::new("v-1");
1846 let target_qty = Quantity::from("0.0001");
1847
1848 assert!(state.pending_modify(&cid).is_none());
1849 assert!(state.pending_modify_target_qty(&cid).is_none());
1850 state.mark_pending_modify(cid, voi, target_qty);
1851 assert_eq!(state.pending_modify(&cid), Some(voi));
1852 assert_eq!(state.pending_modify_target_qty(&cid), Some(target_qty));
1853 state.clear_pending_modify(&cid);
1854 assert!(state.pending_modify(&cid).is_none());
1855 assert!(state.pending_modify_target_qty(&cid).is_none());
1856 }
1857
1858 #[rstest]
1859 fn test_cleanup_terminal_preserves_filled_marker() {
1860 let state = WsDispatchState::new();
1861 let cid = ClientOrderId::new("O-020");
1862 state.register_context(make_context(cid));
1863 state.insert_accepted(cid);
1864 state.mark_pending_modify(cid, VenueOrderId::new("v-1"), Quantity::from("0.0001"));
1865 state.insert_filled(cid);
1866 state.cleanup_terminal(&cid);
1867
1868 assert!(state.lookup_context(&cid).is_none());
1869 assert!(!state.emitted_accepted.contains(&cid));
1870 assert!(state.pending_modify(&cid).is_none());
1871 assert!(state.pending_modify_target_qty(&cid).is_none());
1872 assert!(state.filled_orders.contains(&cid));
1874 }
1875
1876 #[rstest]
1877 fn test_cleanup_terminal_clears_corrective_state() {
1878 let state = WsDispatchState::new();
1879 let cid = ClientOrderId::new("O-021");
1880 let request = sample_request(Decimal::from(1));
1881 state.mark_pending_modify(cid, VenueOrderId::new("v-1"), Quantity::from("1"));
1882 state.stash_modify_request(cid, request.clone());
1883 state.queue_corrective(
1884 cid,
1885 CorrectiveReduce {
1886 oid: 1,
1887 generation: 0,
1888 request,
1889 },
1890 );
1891
1892 assert!(state.modify_request(&cid).is_some());
1893
1894 state.cleanup_terminal(&cid);
1895
1896 assert!(state.modify_request(&cid).is_none());
1897 assert!(state.take_corrective(&cid).is_none());
1898 assert!(state.pending_modify(&cid).is_none());
1899 }
1900
1901 fn sample_request(size: Decimal) -> HyperliquidExchangePlaceOrderRequest {
1902 HyperliquidExchangePlaceOrderRequest {
1903 asset: 0,
1904 is_buy: true,
1905 price: "100".parse::<Decimal>().unwrap(),
1906 size,
1907 reduce_only: false,
1908 kind: HyperliquidExchangeOrderKind::Limit {
1909 limit: HyperliquidExchangeLimitParams {
1910 tif: HyperliquidExchangeTif::Gtc,
1911 },
1912 },
1913 cloid: None,
1914 }
1915 }
1916
1917 #[rstest]
1918 fn test_modify_chain_keeps_both_intents_on_rapid_modifies() {
1919 let state = WsDispatchState::new();
1920 let cid = ClientOrderId::new("O-100");
1921 let g0 =
1922 state.mark_pending_modify(cid, VenueOrderId::new("v-0"), Quantity::from("0.00020"));
1923 let g1 =
1924 state.mark_pending_modify(cid, VenueOrderId::new("v-1"), Quantity::from("0.00030"));
1925
1926 assert_ne!(g0, g1);
1927 assert!(state.has_pending_modify(&cid));
1928 assert_eq!(state.pending_modify(&cid), Some(VenueOrderId::new("v-0")));
1930 assert_eq!(
1931 state.pending_modify_target_qty(&cid),
1932 Some(Quantity::from("0.00020")),
1933 );
1934 assert!(state.pending_modify_contains_old(&cid, VenueOrderId::new("v-0")));
1936 assert!(state.pending_modify_contains_old(&cid, VenueOrderId::new("v-1")));
1937 }
1938
1939 #[rstest]
1940 fn test_clear_modify_generation_preserves_newer_intent() {
1941 let state = WsDispatchState::new();
1942 let cid = ClientOrderId::new("O-101");
1943 let g0 =
1946 state.mark_pending_modify(cid, VenueOrderId::new("v-0"), Quantity::from("0.00020"));
1947 state.mark_pending_modify(cid, VenueOrderId::new("v-0"), Quantity::from("0.00030"));
1948
1949 state.clear_modify_generation(&cid, g0);
1952
1953 assert!(state.has_pending_modify(&cid));
1954 assert_eq!(state.pending_modify(&cid), Some(VenueOrderId::new("v-0")));
1955 assert_eq!(
1956 state.pending_modify_target_qty(&cid),
1957 Some(Quantity::from("0.00030")),
1958 );
1959 assert!(state.pending_modify_contains_old(&cid, VenueOrderId::new("v-0")));
1960 }
1961
1962 #[rstest]
1963 fn test_claim_front_modify_advances_next_old_id() {
1964 let state = WsDispatchState::new();
1965 let cid = ClientOrderId::new("O-102");
1966 state.mark_pending_modify(cid, VenueOrderId::new("v-0"), Quantity::from("0.00020"));
1968 state.mark_pending_modify(cid, VenueOrderId::new("v-0"), Quantity::from("0.00030"));
1969
1970 let claimed = state.claim_front_modify(&cid, VenueOrderId::new("v-1"));
1973 assert_eq!(
1974 claimed.map(|i| i.target_qty),
1975 Some(Quantity::from("0.00020"))
1976 );
1977
1978 assert!(state.has_pending_modify(&cid));
1979 assert_eq!(state.pending_modify(&cid), Some(VenueOrderId::new("v-1")));
1980 assert!(state.pending_modify_contains_old(&cid, VenueOrderId::new("v-1")));
1981 assert!(!state.pending_modify_contains_old(&cid, VenueOrderId::new("v-0")));
1983
1984 let claimed2 = state.claim_front_modify(&cid, VenueOrderId::new("v-2"));
1986 assert_eq!(
1987 claimed2.map(|i| i.target_qty),
1988 Some(Quantity::from("0.00030"))
1989 );
1990 assert!(!state.has_pending_modify(&cid));
1991 assert!(state.pending_modify(&cid).is_none());
1992 }
1993
1994 #[rstest]
1995 fn test_modify_chain_caps_and_evicts_oldest() {
1996 let state = WsDispatchState::new();
1997 let cid = ClientOrderId::new("O-106");
1998 for i in 0..=MAX_PENDING_MODIFY_INTENTS {
2000 let voi = format!("v-{i}");
2001 state.mark_pending_modify(cid, VenueOrderId::new(&voi), Quantity::from("0.00020"));
2002 }
2003
2004 assert!(!state.pending_modify_contains_old(&cid, VenueOrderId::new("v-0")));
2007 let newest = format!("v-{MAX_PENDING_MODIFY_INTENTS}");
2008 assert!(state.pending_modify_contains_old(&cid, VenueOrderId::new(&newest)));
2009 assert_eq!(state.pending_modify(&cid), Some(VenueOrderId::new("v-1")));
2010 }
2011
2012 #[rstest]
2013 fn test_clear_front_modify_reparents_next_old() {
2014 let state = WsDispatchState::new();
2015 let cid = ClientOrderId::new("O-104");
2016 let g_front =
2019 state.mark_pending_modify(cid, VenueOrderId::new("v-1"), Quantity::from("0.00020"));
2020 state.mark_pending_modify(cid, VenueOrderId::new("v-0"), Quantity::from("0.00030"));
2021
2022 state.clear_modify_generation(&cid, g_front);
2026
2027 assert!(state.has_pending_modify(&cid));
2028 assert_eq!(state.pending_modify(&cid), Some(VenueOrderId::new("v-1")));
2029 assert!(state.pending_modify_contains_old(&cid, VenueOrderId::new("v-1")));
2030 assert!(!state.pending_modify_contains_old(&cid, VenueOrderId::new("v-0")));
2031 }
2032
2033 #[rstest]
2034 fn test_clear_non_front_modify_leaves_front_old() {
2035 let state = WsDispatchState::new();
2036 let cid = ClientOrderId::new("O-105");
2037 state.mark_pending_modify(cid, VenueOrderId::new("v-0"), Quantity::from("0.00020"));
2038 let g_back =
2039 state.mark_pending_modify(cid, VenueOrderId::new("v-9"), Quantity::from("0.00030"));
2040
2041 state.clear_modify_generation(&cid, g_back);
2043
2044 assert_eq!(state.pending_modify(&cid), Some(VenueOrderId::new("v-0")));
2045 assert!(!state.pending_modify_contains_old(&cid, VenueOrderId::new("v-9")));
2046 }
2047
2048 #[rstest]
2049 fn test_stash_modify_request_targets_latest_intent() {
2050 let state = WsDispatchState::new();
2051 let cid = ClientOrderId::new("O-103");
2052 state.mark_pending_modify(cid, VenueOrderId::new("v-0"), Quantity::from("0.00020"));
2053 state.stash_modify_request(cid, sample_request(Decimal::from(1)));
2054 state.mark_pending_modify(cid, VenueOrderId::new("v-1"), Quantity::from("0.00030"));
2055 state.stash_modify_request(cid, sample_request(Decimal::from(2)));
2056
2057 assert_eq!(
2059 state.modify_request(&cid).map(|r| r.size),
2060 Some(Decimal::from(1)),
2061 );
2062 state.claim_front_modify(&cid, VenueOrderId::new("v-1"));
2064 assert_eq!(
2065 state.modify_request(&cid).map(|r| r.size),
2066 Some(Decimal::from(2)),
2067 );
2068 }
2069
2070 fn canceled_report(client_order_id: ClientOrderId, venue_order_id: &str) -> OrderStatusReport {
2071 OrderStatusReport::new(
2072 AccountId::from("HYPERLIQUID-001"),
2073 InstrumentId::from("BTC-USD-PERP.HYPERLIQUID"),
2074 Some(client_order_id),
2075 VenueOrderId::new(venue_order_id),
2076 Some(OrderSide::Buy),
2077 OrderType::Limit,
2078 TimeInForce::Gtc,
2079 OrderStatus::Canceled,
2080 Quantity::from("0.0001"),
2081 Quantity::from("0"),
2082 UnixNanos::default(),
2083 UnixNanos::default(),
2084 UnixNanos::default(),
2085 Some(UUID4::new()),
2086 )
2087 }
2088
2089 fn released_cancels(state: &WsDispatchState) -> Vec<OrderStatusReport> {
2090 state
2091 .recv_released_cancels()
2092 .now_or_never()
2093 .unwrap_or_default()
2094 }
2095
2096 fn test_emitter() -> (
2097 ExecutionEventEmitter,
2098 tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
2099 ) {
2100 let mut emitter = ExecutionEventEmitter::new(
2101 get_atomic_clock_realtime(),
2102 TraderId::from("TESTER-001"),
2103 AccountId::from("HYPERLIQUID-001"),
2104 AccountType::Margin,
2105 None,
2106 );
2107 let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
2108 emitter.set_sender(tx);
2109 (emitter, rx)
2110 }
2111
2112 #[rstest]
2113 #[case::bound_leg(Some("v-0"), true)]
2114 #[case::unbound_leg(None, true)]
2115 #[case::superseded_leg(Some("v-1"), false)]
2116 fn test_canceled_for_modified_leg_is_held_unless_superseded(
2117 #[case] bound_venue_order_id: Option<&str>,
2118 #[case] expected_held: bool,
2119 ) {
2120 let (emitter, mut rx) = test_emitter();
2121 let state = WsDispatchState::new();
2122 let cid = ClientOrderId::new("O-107");
2123 state.register_context(make_context(cid));
2124
2125 if let Some(voi) = bound_venue_order_id {
2126 state.record_venue_order_id(cid, VenueOrderId::new(voi));
2127 }
2128
2129 let generation =
2130 state.mark_pending_modify(cid, VenueOrderId::new("v-0"), Quantity::from("0.0001"));
2131 let canceled = canceled_report(cid, "v-0");
2132
2133 let outcome = dispatch_order_event(&canceled, &state, &emitter, UnixNanos::default());
2134 state.clear_modify_generation(&cid, generation);
2135
2136 assert_eq!(outcome, DispatchOutcome::Skip);
2137 assert!(rx.try_recv().is_err());
2138 assert_eq!(
2139 released_cancels(&state),
2140 expected_held
2141 .then_some(canceled)
2142 .into_iter()
2143 .collect::<Vec<_>>(),
2144 );
2145 }
2146
2147 #[rstest]
2148 fn test_held_cancel_releases_when_last_modify_of_its_leg_fails() {
2149 let state = WsDispatchState::new();
2150 let cid = ClientOrderId::new("O-108");
2151 let leg = VenueOrderId::new("v-0");
2152 state.record_venue_order_id(cid, leg);
2153 let g0 = state.mark_pending_modify(cid, leg, Quantity::from("0.00020"));
2154 let g1 = state.mark_pending_modify(cid, leg, Quantity::from("0.00030"));
2155 let canceled = canceled_report(cid, "v-0");
2156
2157 let held = state.hold_cancel(&cid, &canceled);
2158 state.clear_modify_generation(&cid, g0);
2159 let released_while_targeted = released_cancels(&state);
2160 state.clear_modify_generation(&cid, g1);
2161
2162 assert!(held);
2163 assert_eq!(released_while_targeted, vec![]);
2164 assert_eq!(released_cancels(&state), vec![canceled]);
2165 assert!(!state.has_pending_modify(&cid));
2166 }
2167
2168 #[rstest]
2169 #[case::response_cancel_reject(["response", "cancel", "reject"])]
2170 #[case::response_reject_cancel(["response", "reject", "cancel"])]
2171 #[case::cancel_response_reject(["cancel", "response", "reject"])]
2172 #[case::cancel_reject_response(["cancel", "reject", "response"])]
2173 #[case::reject_response_cancel(["reject", "response", "cancel"])]
2174 #[case::reject_cancel_response(["reject", "cancel", "response"])]
2175 fn test_failed_modify_closes_original_once(
2176 #[case] sequence: [&str; 3],
2177 #[values(false, true)] filled: bool,
2178 ) {
2179 let (emitter, mut rx) = test_emitter();
2180 let state = WsDispatchState::new();
2181 let cid = ClientOrderId::new("O-MODIFY-REJECT");
2182 let original = VenueOrderId::new("100");
2183 state.register_context(make_context(cid));
2184 state.record_venue_order_id(cid, original);
2185 state.insert_accepted(cid);
2186 if filled {
2187 state.record_filled_qty(cid, Quantity::from("0.00004"));
2188 }
2189
2190 let generation = state.mark_pending_modify(cid, original, Quantity::from("0.0001"));
2191 let mut canceled = canceled_report(cid, "100");
2192 canceled.ts_last = UnixNanos::from(100);
2193 let mut rejected = canceled_report(cid, "101");
2194 rejected.order_status = OrderStatus::Rejected;
2195 rejected.ts_last = UnixNanos::from(200);
2196
2197 for action in sequence {
2198 match action {
2199 "response" => state.clear_modify_generation(&cid, generation),
2200 "cancel" => {
2201 dispatch_order_event(&canceled, &state, &emitter, UnixNanos::default());
2202 }
2203 "reject" => {
2204 dispatch_order_event(&rejected, &state, &emitter, UnixNanos::default());
2205 }
2206 _ => unreachable!(),
2207 }
2208
2209 for report in released_cancels(&state) {
2210 dispatch_order_event(&report, &state, &emitter, UnixNanos::default());
2211 }
2212 }
2213
2214 let canceled_replay =
2215 dispatch_order_event(&canceled, &state, &emitter, UnixNanos::default());
2216 let rejected_replay =
2217 dispatch_order_event(&rejected, &state, &emitter, UnixNanos::default());
2218 let event = rx.try_recv().unwrap();
2219
2220 let ExecutionEvent::Order(OrderEventAny::Canceled(event)) = event else {
2221 panic!("expected OrderCanceled, received {event:?}");
2222 };
2223
2224 assert_eq!(event.trader_id, emitter.trader_id());
2225 assert_eq!(event.strategy_id, StrategyId::from("S-001"));
2226 assert_eq!(
2227 event.instrument_id,
2228 InstrumentId::from("BTC-USD-PERP.HYPERLIQUID")
2229 );
2230 assert_eq!(event.client_order_id, cid);
2231 assert_eq!(event.venue_order_id, Some(original));
2232 assert_eq!(event.account_id, Some(canceled.account_id));
2233 assert_eq!(event.ts_event, canceled.ts_last);
2234 assert_eq!(event.ts_init, UnixNanos::default());
2235 assert!(!event.reconciliation);
2236 assert_eq!(event.reason, None);
2237 assert_eq!(event.causation_id, None);
2238 assert!(rx.try_recv().is_err());
2239 assert_eq!(canceled_replay, DispatchOutcome::Skip);
2240 assert_eq!(rejected_replay, DispatchOutcome::Skip);
2241 assert!(state.lookup_context(&cid).is_none());
2242 assert!(!state.has_pending_modify(&cid));
2243 }
2244
2245 #[rstest]
2246 fn test_promotion_drops_held_cancel() {
2247 let state = WsDispatchState::new();
2248 let cid = ClientOrderId::new("O-109");
2249 state.record_venue_order_id(cid, VenueOrderId::new("v-0"));
2250 state.mark_pending_modify(cid, VenueOrderId::new("v-0"), Quantity::from("0.00020"));
2251 let g1 =
2252 state.mark_pending_modify(cid, VenueOrderId::new("v-0"), Quantity::from("0.00030"));
2253
2254 let held = state.hold_cancel(&cid, &canceled_report(cid, "v-0"));
2257 state.claim_front_modify(&cid, VenueOrderId::new("v-1"));
2258 state.clear_modify_generation(&cid, g1);
2259
2260 assert!(held);
2261 assert_eq!(released_cancels(&state), vec![]);
2262 assert!(!state.has_pending_modify(&cid));
2263 }
2264}