1use std::fmt::Debug;
44
45use ahash::{AHashMap, AHashSet};
46use anyhow::Context;
47use indexmap::IndexMap;
48use nautilus_common::cache::fifo::{FifoCache, FifoCacheMap};
49use nautilus_core::{
50 UUID4, UnixNanos, collections::AtomicMap, string::secret::REDACTED, time::AtomicTime,
51};
52use nautilus_live::{ExecutionEventEmitter, execution::context::OrderContext};
53use nautilus_model::{
54 enums::{LiquiditySide, OrderSide, OrderStatus, OrderType, TimeInForce},
55 events::{
56 OrderAccepted, OrderCanceled, OrderEventAny, OrderExpired, OrderFillVoided, OrderFilled,
57 OrderRejected, OrderUpdated,
58 },
59 identifiers::{AccountId, ClientOrderId, InstrumentId, TradeId, VenueOrderId},
60 instruments::{Instrument, InstrumentAny},
61 reports::{FillReport, OrderStatusReport},
62 types::{Price, Quantity},
63};
64use rust_decimal::Decimal;
65use ustr::Ustr;
66
67use super::{
68 messages::{
69 PolymarketUserOrder, PolymarketUserOrderStatus, PolymarketUserTrade, UserWsMessage,
70 },
71 parse::parse_timestamp_ms,
72};
73use crate::{
74 common::{
75 enums::{
76 PolymarketOrderSide, PolymarketOrderStatus, PolymarketOrderType, PolymarketSignerType,
77 PolymarketTradeStatus,
78 },
79 parse::parse_decimal_exact,
80 },
81 execution::{
82 context::OrderContextRegistry,
83 fill_tracker::{BufferedFill, FillCorrectionMetadata, OrderFillTrackerMap},
84 get_pusd_currency, is_post_only_crossing,
85 parse::parse_order_status_report,
86 pending::PendingSubmitTracker,
87 reconciliation::admit_selected_trade,
88 settlement::{
89 AdmissionContext, AdmissionError, AdmittedLeg, AdmittedTrade, SettlementAction,
90 SettlementRegistry, TradeEvidence, admit_trade_evidence,
91 },
92 },
93 http::{
94 error::sanitize_error_text,
95 models::{PolymarketOpenOrder, PolymarketTradeReport},
96 },
97};
98
99#[derive(Debug)]
101pub(crate) struct AccountRefreshRequest;
102
103#[derive(Debug, Default)]
108pub(crate) struct WsDispatchState {
109 pub reconciled_fills: FifoCache<(TradeId, VenueOrderId), 10_000>,
110
111 pending_terminal_orders: FifoCacheMap<VenueOrderId, PendingTerminalOrder, 10_000>,
112 terminal_cancel_reports: FifoCacheMap<VenueOrderId, OrderStatusReport, 10_000>,
113
114 pending_commands: AHashMap<ClientOrderId, PendingCommand>,
115 inflight_cancel_markets: AHashSet<InstrumentId>,
116 replaced_venue_order_ids: FifoCache<VenueOrderId, 10_000>,
117 closed_modify_venue_order_ids: FifoCacheMap<VenueOrderId, UnixNanos, 10_000>,
118}
119
120impl WsDispatchState {
121 pub(crate) fn begin_modify(
122 &mut self,
123 client_order_id: ClientOrderId,
124 old_venue_order_id: VenueOrderId,
125 instrument_id: InstrumentId,
126 ) -> bool {
127 if self.pending_commands.contains_key(&client_order_id)
128 || self.replaced_venue_order_ids.contains(&old_venue_order_id)
129 || self.inflight_cancel_markets.contains(&instrument_id)
130 {
131 return false;
132 }
133
134 self.pending_commands.insert(
135 client_order_id,
136 PendingCommand::Modify {
137 old_venue_order_id,
138 instrument_id,
139 cancel_ts: None,
140 replacement: None,
141 },
142 );
143 true
144 }
145
146 pub(crate) fn is_modifying(&self, client_order_id: &ClientOrderId) -> bool {
147 matches!(
148 self.pending_commands.get(client_order_id),
149 Some(PendingCommand::Modify { .. })
150 )
151 }
152
153 pub(crate) fn confirm_modify_cancel(
154 &mut self,
155 client_order_id: ClientOrderId,
156 expected_old_venue_order_id: VenueOrderId,
157 ts_event: UnixNanos,
158 ) -> bool {
159 let Some(PendingCommand::Modify {
160 old_venue_order_id,
161 cancel_ts,
162 ..
163 }) = self.pending_commands.get_mut(&client_order_id)
164 else {
165 return false;
166 };
167
168 if *old_venue_order_id != expected_old_venue_order_id {
169 return false;
170 }
171
172 cancel_ts.get_or_insert(ts_event);
173 true
174 }
175
176 pub(crate) fn set_modify_replacement(
177 &mut self,
178 client_order_id: ClientOrderId,
179 venue_order_id: VenueOrderId,
180 quantity: Quantity,
181 leg_quantity: Quantity,
182 prior_filled: Quantity,
183 price: Price,
184 ) -> bool {
185 let Some(PendingCommand::Modify { replacement, .. }) =
186 self.pending_commands.get_mut(&client_order_id)
187 else {
188 return false;
189 };
190
191 *replacement = Some(PendingModifyReplacement {
192 venue_order_id,
193 quantity,
194 leg_quantity,
195 prior_filled,
196 price,
197 });
198 true
199 }
200
201 #[expect(
211 clippy::too_many_arguments,
212 reason = "promotion coordinates dispatch, contexts, fills, emission, and source-specific time"
213 )]
214 pub(crate) fn promote_modify_replacement(
215 &mut self,
216 venue_order_id: VenueOrderId,
217 order_contexts: &OrderContextRegistry,
218 fill_tracker: &OrderFillTrackerMap,
219 emitter: &ExecutionEventEmitter,
220 clock: &'static AtomicTime,
221 resolve_context: impl FnOnce(VenueOrderId) -> Option<(OrderContext, AccountId)>,
222 event_time: impl FnOnce() -> UnixNanos,
223 ) -> Option<ModifyPromotionActivity> {
224 let promotion = self.claim_modify_replacement(venue_order_id)?;
225 let (mut context, account_id) = resolve_context(promotion.old_venue_order_id)?;
226 context.quantity = promotion.quantity;
227 context.price = Some(promotion.price);
228 order_contexts.register_context(venue_order_id, context);
229 order_contexts.mark_accepted(venue_order_id);
230
231 let ts_event = event_time();
232
233 let updated = OrderUpdated::new(
234 emitter.trader_id(),
235 context.identity.strategy_id,
236 context.identity.instrument_id,
237 promotion.client_order_id,
238 promotion.quantity,
239 UUID4::new(),
240 ts_event,
241 clock.get_time_ns(),
242 false,
243 Some(venue_order_id),
244 Some(account_id),
245 Some(promotion.price),
246 None,
247 None,
248 false,
249 );
250 emitter.send_order_event(OrderEventAny::Updated(updated));
251
252 let fills = fill_tracker.register_and_take_pending_fills(
253 venue_order_id,
254 Some(promotion.client_order_id),
255 promotion.leg_quantity,
256 promotion.quantity.saturating_sub(promotion.leg_quantity),
257 promotion.prior_filled,
258 context.identity.order_side,
259 );
260 let reports = fill_tracker.take_pending_reports(&venue_order_id);
261 Some(ModifyPromotionActivity {
262 client_order_id: promotion.client_order_id,
263 fills,
264 reports,
265 })
266 }
267
268 pub(crate) fn claim_modify_replacement(
269 &mut self,
270 venue_order_id: VenueOrderId,
271 ) -> Option<ModifyPromotion> {
272 let promotion = self.pending_modify_promotion(venue_order_id)?;
273 self.pending_commands.remove(&promotion.client_order_id)?;
274 self.replaced_venue_order_ids
275 .add(promotion.old_venue_order_id);
276 Some(promotion)
277 }
278
279 pub(crate) fn finish_modify_without_replacement(
280 &mut self,
281 client_order_id: ClientOrderId,
282 expected_old_venue_order_id: VenueOrderId,
283 cancellation_proven: bool,
284 ts_event: UnixNanos,
285 ) -> Option<(VenueOrderId, Option<UnixNanos>)> {
286 let Some(PendingCommand::Modify {
287 old_venue_order_id, ..
288 }) = self.pending_commands.get(&client_order_id)
289 else {
290 return None;
291 };
292
293 if *old_venue_order_id != expected_old_venue_order_id {
294 return None;
295 }
296
297 let PendingCommand::Modify {
298 old_venue_order_id,
299 cancel_ts,
300 ..
301 } = self.pending_commands.remove(&client_order_id)?
302 else {
303 return None;
304 };
305
306 let cancel_ts = self
307 .terminal_cancel_reports
308 .get(&old_venue_order_id)
309 .map(|report| report.ts_last)
310 .or(cancel_ts)
311 .or(cancellation_proven.then_some(ts_event));
312
313 if let Some(cancel_ts) = cancel_ts {
314 self.closed_modify_venue_order_ids
315 .insert(old_venue_order_id, cancel_ts);
316 }
317
318 Some((old_venue_order_id, cancel_ts))
319 }
320
321 pub(crate) fn finish_unsubmitted_modifies(
322 &mut self,
323 ) -> Vec<(ClientOrderId, VenueOrderId, Option<UnixNanos>)> {
324 let terminal_cancel_reports = &self.terminal_cancel_reports;
325 let closed_modify_venue_order_ids = &mut self.closed_modify_venue_order_ids;
326 let mut finished = Vec::new();
327
328 self.pending_commands
329 .retain(|client_order_id, command| match command {
330 PendingCommand::Modify {
331 old_venue_order_id,
332 cancel_ts,
333 replacement: None,
334 ..
335 } => {
336 let cancel_ts = terminal_cancel_reports
337 .get(old_venue_order_id)
338 .map(|report| report.ts_last)
339 .or(*cancel_ts);
340 if let Some(cancel_ts) = cancel_ts {
341 closed_modify_venue_order_ids.insert(*old_venue_order_id, cancel_ts);
342 }
343
344 finished.push((*client_order_id, *old_venue_order_id, cancel_ts));
345 false
346 }
347 _ => true,
348 });
349
350 finished
351 }
352
353 pub(crate) fn pending_modify_promotion(
354 &self,
355 venue_order_id: VenueOrderId,
356 ) -> Option<ModifyPromotion> {
357 self.pending_commands
358 .iter()
359 .find_map(|(client_order_id, command)| match command {
360 PendingCommand::Modify {
361 old_venue_order_id,
362 replacement: Some(replacement),
363 ..
364 } if replacement.venue_order_id == venue_order_id => Some(ModifyPromotion {
365 client_order_id: *client_order_id,
366 old_venue_order_id: *old_venue_order_id,
367 venue_order_id,
368 quantity: replacement.quantity,
369 leg_quantity: replacement.leg_quantity,
370 prior_filled: replacement.prior_filled,
371 price: replacement.price,
372 }),
373 _ => None,
374 })
375 }
376
377 pub(crate) fn pending_modify_promotions(&self) -> Vec<ModifyPromotion> {
378 self.pending_commands
379 .iter()
380 .filter_map(|(client_order_id, command)| match command {
381 PendingCommand::Modify {
382 old_venue_order_id,
383 replacement: Some(replacement),
384 ..
385 } => Some(ModifyPromotion {
386 client_order_id: *client_order_id,
387 old_venue_order_id: *old_venue_order_id,
388 venue_order_id: replacement.venue_order_id,
389 quantity: replacement.quantity,
390 leg_quantity: replacement.leg_quantity,
391 prior_filled: replacement.prior_filled,
392 price: replacement.price,
393 }),
394 _ => None,
395 })
396 .collect()
397 }
398
399 pub(crate) fn begin_cancels(&mut self, orders: &[(ClientOrderId, InstrumentId)]) -> bool {
400 if orders.iter().any(|(client_order_id, instrument_id)| {
401 self.pending_commands.contains_key(client_order_id)
402 || self.inflight_cancel_markets.contains(instrument_id)
403 }) {
404 return false;
405 }
406
407 self.pending_commands.extend(
408 orders
409 .iter()
410 .map(|(client_order_id, _)| (*client_order_id, PendingCommand::Cancel)),
411 );
412 true
413 }
414
415 pub(crate) fn begin_available_cancels(
416 &mut self,
417 orders: &[(ClientOrderId, InstrumentId)],
418 ) -> Option<Vec<ClientOrderId>> {
419 if orders.iter().any(|(client_order_id, instrument_id)| {
420 matches!(
421 self.pending_commands.get(client_order_id),
422 Some(PendingCommand::Modify { .. })
423 ) || self.inflight_cancel_markets.contains(instrument_id)
424 }) {
425 return None;
426 }
427
428 let client_order_ids = orders
429 .iter()
430 .filter_map(|(client_order_id, _)| {
431 if self.pending_commands.contains_key(client_order_id) {
432 return None;
433 }
434
435 self.pending_commands
436 .insert(*client_order_id, PendingCommand::Cancel);
437 Some(*client_order_id)
438 })
439 .collect();
440 Some(client_order_ids)
441 }
442
443 pub(crate) fn finish_cancels(&mut self, client_order_ids: &[ClientOrderId]) {
444 for client_order_id in client_order_ids {
445 if matches!(
446 self.pending_commands.get(client_order_id),
447 Some(PendingCommand::Cancel)
448 ) {
449 self.pending_commands.remove(client_order_id);
450 }
451 }
452 }
453
454 pub(crate) fn begin_market_cancel(&mut self, instrument_id: InstrumentId) -> bool {
455 if self.pending_commands.values().any(|command| match command {
456 PendingCommand::Modify {
457 instrument_id: pending_instrument_id,
458 ..
459 } => *pending_instrument_id == instrument_id,
460 PendingCommand::Cancel => false,
461 }) {
462 return false;
463 }
464
465 self.inflight_cancel_markets.insert(instrument_id)
466 }
467
468 pub(crate) fn finish_market_cancel(&mut self, instrument_id: InstrumentId) {
469 self.inflight_cancel_markets.remove(&instrument_id);
470 }
471
472 pub(crate) fn record_terminal_cancel_report(&mut self, report: OrderStatusReport) {
473 self.terminal_cancel_reports
474 .insert(report.venue_order_id, report);
475 }
476
477 pub(crate) fn record_reconciled_fill(
478 &mut self,
479 trade_id: TradeId,
480 venue_order_id: VenueOrderId,
481 ) {
482 self.reconciled_fills.add((trade_id, venue_order_id));
483 }
484
485 pub(crate) fn replaced_venue_order_id(&self, venue_order_id: VenueOrderId) -> bool {
486 self.replaced_venue_order_ids.contains(&venue_order_id)
487 }
488
489 pub(crate) fn reset_session(&mut self) {
490 let retained_cancel_reports = self
491 .pending_commands
492 .values()
493 .filter_map(|command| match command {
494 PendingCommand::Modify {
495 old_venue_order_id, ..
496 } => self
497 .terminal_cancel_reports
498 .get(old_venue_order_id)
499 .cloned(),
500 PendingCommand::Cancel => None,
501 })
502 .collect::<Vec<_>>();
503
504 self.pending_terminal_orders.clear();
505 self.terminal_cancel_reports.clear();
506 for report in retained_cancel_reports {
507 self.terminal_cancel_reports
508 .insert(report.venue_order_id, report);
509 }
510
511 self.pending_commands
512 .retain(|_, command| matches!(command, PendingCommand::Modify { .. }));
513 self.inflight_cancel_markets.clear();
514 }
515
516 fn suppress_modify_cancel(&self, venue_order_id: VenueOrderId) -> bool {
517 self.closed_modify_venue_order_ids
518 .contains_key(&venue_order_id)
519 || self.suppress_modify_cancel_reemit(venue_order_id)
520 }
521
522 pub(crate) fn suppress_modify_cancel_reemit(&self, venue_order_id: VenueOrderId) -> bool {
523 self.replaced_venue_order_ids.contains(&venue_order_id)
524 || self.pending_commands.values().any(|command| {
525 matches!(
526 command,
527 PendingCommand::Modify {
528 old_venue_order_id,
529 ..
530 } if *old_venue_order_id == venue_order_id
531 )
532 })
533 }
534}
535
536#[derive(Clone, Copy, Debug)]
537enum PendingCommand {
538 Modify {
539 old_venue_order_id: VenueOrderId,
540 instrument_id: InstrumentId,
541 cancel_ts: Option<UnixNanos>,
542 replacement: Option<PendingModifyReplacement>,
543 },
544 Cancel,
545}
546
547#[derive(Clone, Copy, Debug)]
548struct PendingModifyReplacement {
549 venue_order_id: VenueOrderId,
550 quantity: Quantity,
551 leg_quantity: Quantity,
552 prior_filled: Quantity,
553 price: Price,
554}
555
556#[derive(Clone, Copy, Debug)]
557pub(crate) struct ModifyPromotion {
558 pub(crate) client_order_id: ClientOrderId,
559 pub(crate) old_venue_order_id: VenueOrderId,
560 pub(crate) venue_order_id: VenueOrderId,
561 pub(crate) quantity: Quantity,
562 pub(crate) leg_quantity: Quantity,
563 pub(crate) prior_filled: Quantity,
564 pub(crate) price: Price,
565}
566
567#[derive(Debug)]
569pub(crate) struct ModifyPromotionActivity {
570 pub(crate) client_order_id: ClientOrderId,
571 pub(crate) fills: Vec<BufferedFill>,
572 pub(crate) reports: Vec<OrderStatusReport>,
573}
574
575#[derive(Clone, Debug)]
576struct PendingTerminalOrder {
577 trade_ids: Vec<String>,
578 ts_event: UnixNanos,
579}
580
581pub(crate) struct WsDispatchContext<'a> {
583 pub token_instruments: &'a AtomicMap<Ustr, InstrumentAny>,
584 pub fill_tracker: &'a OrderFillTrackerMap,
585 pub settlement: &'a SettlementRegistry,
586 pub pending_submits: &'a PendingSubmitTracker,
587 pub order_contexts: &'a OrderContextRegistry,
588 pub emitter: &'a ExecutionEventEmitter,
589 pub account_id: AccountId,
590 pub clock: &'static AtomicTime,
591 pub signer_type: PolymarketSignerType,
592 pub user_address: &'a str,
593 pub user_api_key: &'a str,
594}
595
596impl Debug for WsDispatchContext<'_> {
597 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
598 f.debug_struct(stringify!(WsDispatchContext))
599 .field("token_instruments", &self.token_instruments)
600 .field("fill_tracker", &self.fill_tracker)
601 .field("settlement", &self.settlement)
602 .field("pending_submits", &self.pending_submits)
603 .field("order_contexts", &self.order_contexts)
604 .field("emitter", &self.emitter)
605 .field("account_id", &self.account_id)
606 .field("clock", &self.clock)
607 .field("user_address", &self.user_address)
608 .field("user_api_key", &REDACTED)
609 .finish()
610 }
611}
612
613impl WsDispatchContext<'_> {
614 pub(crate) fn admission_context(&self) -> AdmissionContext<'_> {
615 AdmissionContext {
616 signer_type: self.signer_type,
617 user_address: self.user_address,
618 api_key: self.user_api_key,
619 pusd: get_pusd_currency(),
620 instruments: self.token_instruments,
621 fee_bases: Some(self.settlement),
622 }
623 }
624}
625
626pub(crate) fn dispatch_user_message(
628 message: &UserWsMessage,
629 ctx: &WsDispatchContext<'_>,
630 state: &mut WsDispatchState,
631) -> Option<AccountRefreshRequest> {
632 match message {
633 UserWsMessage::Order(order) => {
634 dispatch_order_update(order, ctx, state);
635 None
636 }
637 UserWsMessage::Trade(trade) => dispatch_trade_update(trade, ctx, state),
638 }
639}
640
641fn dispatch_order_update(
642 order: &PolymarketUserOrder,
643 ctx: &WsDispatchContext<'_>,
644 state: &mut WsDispatchState,
645) {
646 let Some(status) = order.status.as_ref() else {
647 log::warn!("Ignoring order update without status: {}", order.id);
648 return;
649 };
650
651 let Some(order_type) = order.order_type else {
652 log::warn!("Ignoring order update without order_type: {}", order.id);
653 return;
654 };
655
656 let instruments = ctx.token_instruments.load();
657 let instrument = match instruments.get(&order.asset_id) {
658 Some(i) => i,
659 None => {
660 log::warn!("Unknown asset_id in order update: {}", order.asset_id);
661 return;
662 }
663 };
664
665 let ts_event = parse_timestamp_ms(&order.timestamp).unwrap_or_else(|_| ctx.clock.get_time_ns());
666 let venue_order_id = VenueOrderId::from(order.id.as_str());
667
668 let ts_init = ctx.clock.get_time_ns();
669 let mut report = match build_ws_order_status_report(
670 order,
671 status,
672 order_type,
673 instrument,
674 ctx.account_id,
675 ts_event,
676 ts_init,
677 ) {
678 Ok(report) => report,
679 Err(e) => {
680 log::warn!("Ignoring invalid order update {}: {e}", order.id);
681 return;
682 }
683 };
684 let mut promoted_fills = Vec::new();
685 let mut promoted_reports = Vec::new();
686 let promoted_client_order_id = if state.pending_modify_promotion(venue_order_id).is_some() {
687 if report.order_status == OrderStatus::Rejected {
688 reject_modify_replacement(venue_order_id, &report, ts_event, ctx, state);
689 return;
690 }
691
692 promote_modify_replacement_from_ws(
693 venue_order_id,
694 ts_event,
695 ctx,
696 state,
697 &mut promoted_fills,
698 &mut promoted_reports,
699 )
700 } else {
701 None
702 };
703
704 let local_client_order_id = promoted_client_order_id.or_else(|| {
705 ctx.order_contexts
706 .get(&venue_order_id)
707 .and_then(|_| ctx.pending_submits.client_order_id(&venue_order_id))
708 });
709
710 report.client_order_id = local_client_order_id;
711 let (is_accepted, mut buffered_fills) = take_status_update_fills(&report, ctx);
712
713 buffered_fills.splice(0..0, promoted_fills);
714
715 if let Some(tracked_filled) = ctx.fill_tracker.get_cumulative_filled(&venue_order_id)
718 && report.filled_qty > tracked_filled
719 {
720 log::debug!(
721 "Capping filled_qty for {venue_order_id} from {} to {} (awaiting trade messages)",
722 report.filled_qty,
723 tracked_filled,
724 );
725 report.filled_qty = tracked_filled;
726 }
727
728 if matches!(
732 report.order_status,
733 OrderStatus::Canceled | OrderStatus::Expired
734 ) {
735 state
736 .terminal_cancel_reports
737 .insert(venue_order_id, report.clone());
738 }
739
740 let suppress_cancel = matches!(
741 report.order_status,
742 OrderStatus::Canceled | OrderStatus::Expired
743 ) && state.suppress_modify_cancel(venue_order_id);
744
745 let context = ctx.order_contexts.get(&venue_order_id);
748
749 for fill in buffered_fills {
751 match context {
752 Some(context) => {
753 emit_buffered_order_filled(&context, &fill, ctx);
754 }
755 None => emit_buffered_fill_report(fill, ctx),
756 }
757 }
758
759 for buffered in promoted_reports {
760 if matches!(
761 buffered.order_status,
762 OrderStatus::Canceled | OrderStatus::Expired
763 ) {
764 state
765 .terminal_cancel_reports
766 .insert(venue_order_id, buffered.clone());
767 }
768
769 if let Some(context) = context {
770 emit_tracked_order_status(&buffered, &context, buffered.ts_last, ctx);
771 }
772 }
773
774 if suppress_cancel {
775 log::debug!("Suppressing stale cancel for modified venue leg {venue_order_id}");
776 return;
777 }
778
779 if is_accepted || local_client_order_id.is_some() {
780 match context {
781 Some(context) => emit_tracked_order_status(&report, &context, ts_event, ctx),
782 None => ctx.emitter.send_order_status_report(report),
783 }
784 } else if let Some(report) = ctx
785 .fill_tracker
786 .accept_or_buffer_report(venue_order_id, report)
787 {
788 match ctx.order_contexts.get(&venue_order_id) {
790 Some(context) => emit_tracked_order_status(&report, &context, ts_event, ctx),
791 None => ctx.emitter.send_order_status_report(report),
792 }
793 }
794
795 if status.status == PolymarketOrderStatus::Matched
796 && let Some(trade_ids) = order.associate_trades.clone().filter(|ids| !ids.is_empty())
797 {
798 state.pending_terminal_orders.insert(
799 venue_order_id,
800 PendingTerminalOrder {
801 trade_ids,
802 ts_event,
803 },
804 );
805 emit_quantity_normalization_if_ready(venue_order_id, ctx, state);
806 }
807}
808
809fn take_status_update_fills(
813 report: &OrderStatusReport,
814 ctx: &WsDispatchContext<'_>,
815) -> (bool, Vec<BufferedFill>) {
816 let venue_order_id = report.venue_order_id;
817 let is_accepted = ctx.fill_tracker.contains(&venue_order_id);
818
819 if report.client_order_id.is_some()
820 && !is_accepted
821 && report.order_status != OrderStatus::Rejected
822 {
823 let fills = ctx.fill_tracker.register_and_take_pending_fills(
824 venue_order_id,
825 report.client_order_id,
826 report.quantity,
827 Quantity::zero(report.quantity.precision),
828 Quantity::zero(report.quantity.precision),
829 report
830 .order_side
831 .expect("order status report side must be Buy or Sell"),
832 );
833 return (true, fills);
834 }
835
836 if is_accepted {
837 let fills = ctx
838 .fill_tracker
839 .take_pending_fills(venue_order_id, report.client_order_id);
840 return (true, fills);
841 }
842
843 (false, Vec::new())
844}
845
846fn promote_modify_replacement_from_ws(
847 venue_order_id: VenueOrderId,
848 ts_event: UnixNanos,
849 ctx: &WsDispatchContext<'_>,
850 state: &mut WsDispatchState,
851 buffered_fills: &mut Vec<BufferedFill>,
852 buffered_reports: &mut Vec<OrderStatusReport>,
853) -> Option<ClientOrderId> {
854 let activity = state.promote_modify_replacement(
855 venue_order_id,
856 ctx.order_contexts,
857 ctx.fill_tracker,
858 ctx.emitter,
859 ctx.clock,
860 |old_venue_order_id| {
861 let Some(context) = ctx.order_contexts.get(&old_venue_order_id) else {
862 log::error!(
863 "Cannot promote Polymarket replacement {venue_order_id}: old venue leg {old_venue_order_id} has no context"
864 );
865 return None;
866 };
867
868 Some((context, ctx.account_id))
869 },
870 || ts_event,
871 )?;
872
873 buffered_fills.extend(activity.fills);
874 buffered_reports.extend(activity.reports);
875 Some(activity.client_order_id)
876}
877
878fn reject_modify_replacement(
879 venue_order_id: VenueOrderId,
880 report: &OrderStatusReport,
881 ts_event: UnixNanos,
882 ctx: &WsDispatchContext<'_>,
883 state: &mut WsDispatchState,
884) {
885 let Some(promotion) = state.pending_modify_promotion(venue_order_id) else {
886 return;
887 };
888
889 let Some((old_venue_order_id, cancel_ts)) = state.finish_modify_without_replacement(
890 promotion.client_order_id,
891 promotion.old_venue_order_id,
892 true,
893 ts_event,
894 ) else {
895 return;
896 };
897
898 let Some(context) = ctx.order_contexts.get(&old_venue_order_id) else {
899 return;
900 };
901
902 let reason = report
903 .cancel_reason
904 .as_deref()
905 .unwrap_or("replacement order rejected");
906 ctx.emitter.emit_order_modify_rejected_event(
907 context.identity.strategy_id,
908 context.identity.instrument_id,
909 context.identity.client_order_id,
910 Some(old_venue_order_id),
911 &sanitize_error_text(reason),
912 ts_event,
913 None,
914 );
915
916 if let Some(cancel_ts) = cancel_ts {
917 emit_order_canceled(&context, old_venue_order_id, cancel_ts, ctx);
918 }
919}
920
921fn emit_buffered_order_filled(
922 context: &OrderContext,
923 buffered: &BufferedFill,
924 ctx: &WsDispatchContext<'_>,
925) {
926 let fill = &buffered.report;
927 ensure_accepted(context, fill.venue_order_id, fill.ts_event, ctx);
928
929 let info = buffered
930 .correction
931 .as_ref()
932 .and_then(|correction| correction.info.clone());
933 let filled = build_order_filled(context, fill, info, ctx);
934 ctx.fill_tracker.emit_buffered_fill(
935 filled,
936 || buffered.claim(ctx.settlement),
937 |filled, new_qty| {
938 if let Some(new_qty) = new_qty {
939 emit_buy_overfill_update(context, fill.venue_order_id, new_qty, fill.ts_event, ctx);
940 }
941
942 ctx.settlement.note_leg_enqueued(&fill.trade_id);
943 ctx.emitter.send_order_event(OrderEventAny::Filled(filled));
944 },
945 );
946}
947
948fn emit_buffered_fill_report(buffered: BufferedFill, ctx: &WsDispatchContext<'_>) {
951 let report = &buffered.report;
952 if !buffered.claim(ctx.settlement) {
953 ctx.fill_tracker
954 .reverse_fill(&report.venue_order_id, report.last_qty);
955 return;
956 }
957
958 let trade_id = report.trade_id;
959 ctx.emitter.send_fill_report(buffered.report);
960 ctx.settlement.note_leg_reported(&trade_id);
961}
962
963fn is_ready_for_terminal_normalization(
964 venue_order_id: &VenueOrderId,
965 ctx: &WsDispatchContext<'_>,
966 state: &WsDispatchState,
967) -> bool {
968 state
969 .pending_terminal_orders
970 .get(venue_order_id)
971 .is_some_and(|pending| {
972 pending
973 .trade_ids
974 .iter()
975 .all(|trade_id| ctx.settlement.authorizes_terminal_bookkeeping(trade_id))
976 })
977}
978
979fn emit_quantity_normalization_if_ready(
980 venue_order_id: VenueOrderId,
981 ctx: &WsDispatchContext<'_>,
982 state: &mut WsDispatchState,
983) {
984 if !is_ready_for_terminal_normalization(&venue_order_id, ctx, state)
985 || ctx.settlement.blocks_terminal_bookkeeping(&venue_order_id)
986 {
987 return;
988 }
989
990 let Some(pending) = state.pending_terminal_orders.remove(&venue_order_id) else {
991 return;
992 };
993
994 let Some(context) = ctx.order_contexts.get(&venue_order_id) else {
995 log::warn!("Cannot normalize terminal order {venue_order_id} without a local context");
996 return;
997 };
998
999 if let Some(quantity) = ctx
1000 .fill_tracker
1001 .check_terminal_quantity_normalization(&venue_order_id)
1002 {
1003 emit_terminal_quantity_update(&context, venue_order_id, quantity, pending.ts_event, ctx);
1004 }
1005}
1006
1007fn emit_taker_terminal_status(
1014 venue_order_id: VenueOrderId,
1015 ctx: &WsDispatchContext<'_>,
1016 ts_event: UnixNanos,
1017) {
1018 let Some(context) = ctx.order_contexts.get(&venue_order_id) else {
1019 return;
1020 };
1021
1022 if context.time_in_force != TimeInForce::Fok && context.time_in_force != TimeInForce::Ioc {
1023 return;
1024 }
1025
1026 if ctx.settlement.blocks_terminal_bookkeeping(&venue_order_id) {
1027 return;
1028 }
1029
1030 if context.time_in_force == TimeInForce::Fok {
1031 if let Some(quantity) = ctx
1032 .fill_tracker
1033 .check_terminal_quantity_normalization(&venue_order_id)
1034 {
1035 emit_terminal_quantity_update(&context, venue_order_id, quantity, ts_event, ctx);
1036 }
1037 return;
1038 }
1039
1040 if context.time_in_force == TimeInForce::Ioc
1041 && let Some(remainder) = ctx
1042 .fill_tracker
1043 .take_terminal_ioc_remainder(&venue_order_id)
1044 {
1045 log::debug!(
1046 "Closing terminal IOC order {venue_order_id} as Canceled (unfilled remainder={remainder})"
1047 );
1048 emit_order_canceled(&context, venue_order_id, ts_event, ctx);
1049 }
1050}
1051
1052fn dispatch_trade_update(
1053 trade: &PolymarketUserTrade,
1054 ctx: &WsDispatchContext<'_>,
1055 state: &mut WsDispatchState,
1056) -> Option<AccountRefreshRequest> {
1057 let admitted =
1058 match admit_trade_evidence(TradeEvidence::Stream(trade), &ctx.admission_context()) {
1059 Ok(admitted) => admitted,
1060 Err(AdmissionError::UnknownInstrument(token)) => {
1061 log::warn!(
1062 "Deferring trade {} until its instrument {token} is available",
1063 trade.id
1064 );
1065 return None;
1066 }
1067 Err(AdmissionError::Unowned) => {
1068 ctx.settlement.quarantine_known_trade(&trade.id);
1069
1070 log::warn!("Stream trade {} has no owned legs", trade.id);
1071 return None;
1072 }
1073 Err(AdmissionError::Untimestamped(e) | AdmissionError::Invalid(e)) => {
1074 log::error!("Cannot admit stream evidence for trade {}: {e}", trade.id);
1075 ctx.settlement.quarantine_invalid_trade(&trade.id);
1076 return None;
1077 }
1078 };
1079
1080 let actions = ctx.settlement.admit_stream_trade(&admitted);
1081 execute_settlement_actions(actions, trade_fill_info(trade).as_ref(), ctx, state);
1082
1083 if !ctx.settlement.is_trade_confirmed(&admitted.venue_trade_id) {
1084 return None;
1085 }
1086
1087 if ctx
1090 .settlement
1091 .authorizes_terminal_bookkeeping(&admitted.venue_trade_id)
1092 {
1093 let ts_event =
1094 parse_timestamp_ms(&trade.timestamp).unwrap_or_else(|_| ctx.clock.get_time_ns());
1095 confirm_trade_bookkeeping(&admitted, ts_event, ctx, state);
1096 }
1097 Some(AccountRefreshRequest)
1098}
1099
1100pub(crate) fn execute_settlement_actions(
1102 actions: Vec<SettlementAction>,
1103 fill_info: Option<&IndexMap<Ustr, Ustr>>,
1104 ctx: &WsDispatchContext<'_>,
1105 state: &mut WsDispatchState,
1106) {
1107 for action in actions {
1108 match action {
1109 SettlementAction::ApplyLeg {
1110 venue_trade_id,
1111 leg,
1112 } => {
1113 apply_authorized_leg(&venue_trade_id, &leg, fill_info.cloned(), ctx, state);
1114 }
1115 SettlementAction::VoidAppliedFill {
1116 venue_trade_id,
1117 fill,
1118 } => {
1119 emit_void_for_applied_fill(
1120 &venue_trade_id,
1121 &fill,
1122 ctx.fill_tracker,
1123 ctx.emitter,
1124 ctx.clock,
1125 );
1126 }
1127 }
1128 }
1129}
1130
1131pub(crate) fn apply_rest_trade_evidence(
1136 trade: &PolymarketTradeReport,
1137 ctx: &WsDispatchContext<'_>,
1138 state: &mut WsDispatchState,
1139) {
1140 let admitted = match admit_trade_evidence(TradeEvidence::Rest(trade), &ctx.admission_context())
1141 {
1142 Ok(admitted) => admitted,
1143 Err(e) => {
1144 log::warn!(
1145 "Targeted REST evidence for Polymarket trade {} did not pass admission: {e}; \
1146 retrying",
1147 trade.id
1148 );
1149 return;
1150 }
1151 };
1152
1153 apply_admitted_rest_trade(&admitted, trade, ctx, state);
1154}
1155
1156pub(crate) fn apply_uncertain_order_evidence(
1166 venue_order_id: VenueOrderId,
1167 order: &PolymarketOpenOrder,
1168 trades: &[PolymarketTradeReport],
1169 ctx: &WsDispatchContext<'_>,
1170 state: &mut WsDispatchState,
1171) -> bool {
1172 let Some((context, instrument)) = submitted_order_context(venue_order_id, order, ctx) else {
1173 return false;
1174 };
1175
1176 let trades_applied =
1177 apply_order_trade_evidence(venue_order_id, order, trades, ctx, |admitted, trade| {
1178 let actions = ctx.settlement.admit_rest_result(admitted);
1179 execute_settlement_actions(actions, rest_trade_info(trade).as_ref(), ctx, state);
1180 });
1181
1182 if !trades_applied {
1183 return false;
1184 }
1185
1186 let report = match parse_order_status_report(
1187 order,
1188 instrument.id(),
1189 ctx.account_id,
1190 ctx.pending_submits.client_order_id(&venue_order_id),
1191 instrument.price_precision(),
1192 instrument.size_precision(),
1193 ctx.clock.get_time_ns(),
1194 ) {
1195 Ok(report) => report,
1196 Err(e) => {
1197 log::warn!("Cannot apply REST status of uncertain order {venue_order_id}: {e}");
1198 return false;
1199 }
1200 };
1201
1202 let (_, buffered_fills) = take_status_update_fills(&report, ctx);
1203
1204 for fill in buffered_fills {
1205 emit_buffered_order_filled(&context, &fill, ctx);
1206 }
1207
1208 if ctx.order_contexts.is_closed(venue_order_id)
1209 || (report.order_status == OrderStatus::Canceled
1210 && state.suppress_modify_cancel_reemit(venue_order_id))
1211 {
1212 return true;
1213 }
1214
1215 let faulted = order_trades_block_terminal_bookkeeping(venue_order_id, trades, ctx);
1216 let inferred_cancel = order.status == PolymarketOrderStatus::Matched
1218 && report.order_status == OrderStatus::Canceled;
1219
1220 if faulted && inferred_cancel {
1221 ensure_accepted(&context, venue_order_id, report.ts_last, ctx);
1222 } else {
1223 emit_tracked_order_status(&report, &context, report.ts_last, ctx);
1224 }
1225
1226 if report.order_status == OrderStatus::Filled && !faulted {
1229 emit_taker_terminal_status(venue_order_id, ctx, report.ts_last);
1230 }
1231
1232 true
1233}
1234
1235fn order_trades_block_terminal_bookkeeping(
1236 venue_order_id: VenueOrderId,
1237 trades: &[PolymarketTradeReport],
1238 ctx: &WsDispatchContext<'_>,
1239) -> bool {
1240 ctx.settlement.blocks_terminal_bookkeeping(&venue_order_id)
1241 || trades.iter().any(|trade| {
1242 trade_touches_order(trade, venue_order_id)
1243 && ctx.settlement.is_trade_hard_faulted(&trade.id)
1244 })
1245}
1246
1247fn trade_touches_order(trade: &PolymarketTradeReport, venue_order_id: VenueOrderId) -> bool {
1248 trade.taker_order_id == venue_order_id.as_str()
1249 || trade
1250 .maker_orders
1251 .iter()
1252 .any(|maker| maker.order_id == venue_order_id.as_str())
1253}
1254
1255pub(crate) fn apply_stream_gap_order_evidence(
1262 venue_order_id: VenueOrderId,
1263 order: &PolymarketOpenOrder,
1264 trades: &[PolymarketTradeReport],
1265 ctx: &WsDispatchContext<'_>,
1266 state: &mut WsDispatchState,
1267) -> bool {
1268 if submitted_order_context(venue_order_id, order, ctx).is_none() {
1269 return false;
1270 }
1271
1272 apply_order_trade_evidence(venue_order_id, order, trades, ctx, |admitted, trade| {
1273 if ctx.settlement.knows_trade(admitted) {
1274 return;
1275 }
1276
1277 log::info!(
1278 "Discovered Polymarket trade {} on order {venue_order_id} missed during a user \
1279 stream disconnect",
1280 admitted.venue_trade_id
1281 );
1282 apply_admitted_rest_trade(admitted, trade, ctx, state);
1283 })
1284}
1285
1286fn apply_admitted_rest_trade(
1287 admitted: &AdmittedTrade,
1288 trade: &PolymarketTradeReport,
1289 ctx: &WsDispatchContext<'_>,
1290 state: &mut WsDispatchState,
1291) {
1292 let actions = ctx.settlement.admit_rest_result(admitted);
1293 execute_settlement_actions(actions, rest_trade_info(trade).as_ref(), ctx, state);
1294
1295 if ctx
1296 .settlement
1297 .authorizes_terminal_bookkeeping(&admitted.venue_trade_id)
1298 {
1299 confirm_trade_bookkeeping(admitted, ctx.clock.get_time_ns(), ctx, state);
1300 }
1301}
1302
1303fn submitted_order_context(
1306 venue_order_id: VenueOrderId,
1307 order: &PolymarketOpenOrder,
1308 ctx: &WsDispatchContext<'_>,
1309) -> Option<(OrderContext, InstrumentAny)> {
1310 let (Some(context), Some(instrument)) = (
1311 ctx.order_contexts.get(&venue_order_id),
1312 ctx.token_instruments.get_cloned(&order.asset_id),
1313 ) else {
1314 return None;
1315 };
1316
1317 if order.id != venue_order_id.as_str()
1318 || instrument.id() != context.identity.instrument_id
1319 || OrderSide::from(order.side) != context.identity.order_side
1320 {
1321 log::warn!(
1322 "REST order evidence for uncertain order {venue_order_id} contradicts the submitted \
1323 order"
1324 );
1325 return None;
1326 }
1327
1328 Some((context, instrument))
1329}
1330
1331fn apply_order_trade_evidence(
1336 venue_order_id: VenueOrderId,
1337 order: &PolymarketOpenOrder,
1338 trades: &[PolymarketTradeReport],
1339 ctx: &WsDispatchContext<'_>,
1340 mut apply: impl FnMut(&AdmittedTrade, &PolymarketTradeReport),
1341) -> bool {
1342 let Some(order_trades) = uncertain_order_trades(venue_order_id, trades) else {
1343 return false;
1344 };
1345
1346 if order_trades
1347 .iter()
1348 .any(|trade| trade.status.is_pending_settlement())
1349 {
1350 return false;
1351 }
1352
1353 let mut confirmed_qty = Decimal::ZERO;
1354
1355 for trade in order_trades {
1356 let admitted =
1357 match admit_trade_evidence(TradeEvidence::Rest(trade), &ctx.admission_context()) {
1358 Ok(admitted) => admitted,
1359 Err(e) => {
1360 log::warn!(
1361 "Cannot admit REST evidence for trade {} of uncertain order \
1362 {venue_order_id}: {e}",
1363 trade.id
1364 );
1365 return false;
1366 }
1367 };
1368
1369 if admitted.status == PolymarketTradeStatus::Confirmed {
1370 confirmed_qty += admitted
1371 .legs
1372 .iter()
1373 .filter(|leg| leg.venue_order_id == venue_order_id)
1374 .map(|leg| leg.last_qty.as_decimal())
1375 .sum::<Decimal>();
1376 }
1377
1378 apply(&admitted, trade);
1379 }
1380
1381 if confirmed_qty < order.size_matched {
1383 log::debug!(
1384 "Confirmed REST trades cover {confirmed_qty} of {} matched for uncertain order \
1385 {venue_order_id}; retrying",
1386 order.size_matched
1387 );
1388 return false;
1389 }
1390
1391 true
1392}
1393
1394fn uncertain_order_trades(
1397 venue_order_id: VenueOrderId,
1398 trades: &[PolymarketTradeReport],
1399) -> Option<Vec<&PolymarketTradeReport>> {
1400 let mut selected = AHashMap::new();
1401 let mut order_trades = Vec::new();
1402
1403 for trade in trades
1404 .iter()
1405 .filter(|trade| trade_touches_order(trade, venue_order_id))
1406 {
1407 match admit_selected_trade(&mut selected, trade) {
1408 Ok(true) => order_trades.push(trade),
1409 Ok(false) => {}
1410 Err(e) => {
1411 log::warn!(
1412 "REST evidence for uncertain order {venue_order_id} is contradictory: {e}"
1413 );
1414 return None;
1415 }
1416 }
1417 }
1418
1419 Some(order_trades)
1420}
1421
1422fn apply_authorized_leg(
1426 venue_trade_id: &str,
1427 leg: &AdmittedLeg,
1428 fill_info: Option<IndexMap<Ustr, Ustr>>,
1429 ctx: &WsDispatchContext<'_>,
1430 state: &mut WsDispatchState,
1431) {
1432 let venue_order_id = leg.venue_order_id;
1433
1434 if state
1436 .reconciled_fills
1437 .contains(&(leg.trade_id, venue_order_id))
1438 {
1439 ctx.settlement.note_leg_reported(&leg.trade_id);
1440 return;
1441 }
1442
1443 let mut report = leg.fill_report(ctx.account_id, ctx.clock.get_time_ns());
1444 report.client_order_id = ctx.pending_submits.client_order_id(&venue_order_id);
1445
1446 let correction_info = fill_info.clone();
1447
1448 let correction = FillCorrectionMetadata {
1449 venue_trade_id: venue_trade_id.to_string(),
1450 info: fill_info,
1451 };
1452
1453 let mut promoted_reports = Vec::new();
1454
1455 if state.pending_modify_promotion(venue_order_id).is_some() {
1456 let mut buffered_fills = Vec::new();
1457 report.client_order_id = promote_modify_replacement_from_ws(
1458 venue_order_id,
1459 report.ts_event,
1460 ctx,
1461 state,
1462 &mut buffered_fills,
1463 &mut promoted_reports,
1464 );
1465 emit_promoted_ws_fills(venue_order_id, buffered_fills, ctx);
1466 }
1467
1468 if let Some(report) = ctx
1469 .fill_tracker
1470 .accept_or_buffer_fill(venue_order_id, report, correction)
1471 {
1472 match ctx.order_contexts.get(&venue_order_id) {
1473 Some(context) => {
1474 emit_order_filled(&context, &report, correction_info, ctx);
1475 }
1476 None => {
1477 ctx.emitter.send_fill_report(report);
1478 ctx.settlement.note_leg_reported(&leg.trade_id);
1479 }
1480 }
1481
1482 reemit_terminal_cancel(venue_order_id, state, ctx);
1483 }
1484
1485 emit_promoted_ws_reports(venue_order_id, promoted_reports, ctx, state);
1486}
1487
1488fn confirm_trade_bookkeeping(
1491 admitted: &AdmittedTrade,
1492 ts_event: UnixNanos,
1493 ctx: &WsDispatchContext<'_>,
1494 state: &mut WsDispatchState,
1495) {
1496 for leg in &admitted.legs {
1497 emit_quantity_normalization_if_ready(leg.venue_order_id, ctx, state);
1498
1499 if leg.liquidity_side == LiquiditySide::Taker {
1500 emit_taker_terminal_status(leg.venue_order_id, ctx, ts_event);
1501 }
1502 }
1503}
1504
1505fn emit_promoted_ws_fills(
1506 venue_order_id: VenueOrderId,
1507 buffered_fills: Vec<BufferedFill>,
1508 ctx: &WsDispatchContext<'_>,
1509) {
1510 let context = ctx.order_contexts.get(&venue_order_id);
1511
1512 for fill in buffered_fills {
1513 match context {
1514 Some(context) => emit_buffered_order_filled(&context, &fill, ctx),
1515 None => emit_buffered_fill_report(fill, ctx),
1516 }
1517 }
1518}
1519
1520fn emit_promoted_ws_reports(
1521 venue_order_id: VenueOrderId,
1522 buffered_reports: Vec<OrderStatusReport>,
1523 ctx: &WsDispatchContext<'_>,
1524 state: &mut WsDispatchState,
1525) {
1526 let context = ctx.order_contexts.get(&venue_order_id);
1527
1528 for report in buffered_reports {
1529 if matches!(
1530 report.order_status,
1531 OrderStatus::Canceled | OrderStatus::Expired
1532 ) {
1533 state.record_terminal_cancel_report(report.clone());
1534 }
1535
1536 match context {
1537 Some(context) => emit_tracked_order_status(&report, &context, report.ts_last, ctx),
1538 None => ctx.emitter.send_order_status_report(report),
1539 }
1540 }
1541}
1542
1543fn reemit_terminal_cancel(
1553 venue_order_id: VenueOrderId,
1554 state: &WsDispatchState,
1555 ctx: &WsDispatchContext<'_>,
1556) {
1557 if ctx.fill_tracker.is_fully_filled(&venue_order_id) {
1558 return;
1559 }
1560
1561 if state.suppress_modify_cancel_reemit(venue_order_id) {
1562 return;
1563 }
1564
1565 let cancel_ts = state
1566 .closed_modify_venue_order_ids
1567 .get(&venue_order_id)
1568 .copied()
1569 .or_else(|| {
1570 state
1571 .terminal_cancel_reports
1572 .get(&venue_order_id)
1573 .map(|report| report.ts_last)
1574 });
1575
1576 if let Some(cancel_ts) = cancel_ts {
1577 log::debug!("Re-emitting cancel for {venue_order_id} after fill to restore terminal state");
1578 match ctx.order_contexts.get(&venue_order_id) {
1579 Some(context) => {
1580 if state
1581 .terminal_cancel_reports
1582 .get(&venue_order_id)
1583 .is_some_and(|report| report.order_status == OrderStatus::Expired)
1584 {
1585 emit_order_expired(&context, venue_order_id, cancel_ts, ctx);
1586 } else {
1587 emit_order_canceled(&context, venue_order_id, cancel_ts, ctx);
1588 }
1589 }
1590 None => {
1591 if let Some(cancel_report) = state.terminal_cancel_reports.get(&venue_order_id) {
1592 ctx.emitter.send_order_status_report(cancel_report.clone());
1593 }
1594 }
1595 }
1596 }
1597}
1598
1599fn build_ws_order_status_report(
1600 order: &PolymarketUserOrder,
1601 status: &PolymarketUserOrderStatus,
1602 order_type: PolymarketOrderType,
1603 instrument: &InstrumentAny,
1604 account_id: AccountId,
1605 ts_event: UnixNanos,
1606 ts_init: UnixNanos,
1607) -> anyhow::Result<OrderStatusReport> {
1608 let venue_order_id = VenueOrderId::from(order.id.as_str());
1609 let order_status = gtd_expiry_status(
1610 crate::execution::parse::resolve_order_status(status.status, order.event_type),
1611 order_type,
1612 order.expiration.as_deref(),
1613 ts_event,
1614 );
1615 let order_side = OrderSide::from(order.side);
1616 let time_in_force = TimeInForce::from(order_type);
1617 let size_precision = instrument.size_precision();
1618 let price_precision = instrument.price_precision();
1619 let price_dec = parse_decimal_exact(&order.price)?;
1620 anyhow::ensure!(
1621 price_dec > Decimal::ZERO && price_dec < Decimal::ONE,
1622 "order price must be in (0, 1)"
1623 );
1624 let quantity_dec = parse_decimal_exact(&order.original_size)?;
1625 let filled_dec = if order.size_matched.is_empty() {
1627 Decimal::ZERO
1628 } else {
1629 parse_decimal_exact(&order.size_matched)?
1630 };
1631 anyhow::ensure!(
1632 quantity_dec > Decimal::ZERO && filled_dec >= Decimal::ZERO,
1633 "invalid order quantity"
1634 );
1635 let quantity = Quantity::from_decimal_dp(
1636 original_size_to_shares(quantity_dec, price_dec, order.side, order_type)?,
1637 size_precision,
1638 )?;
1639 let filled_qty = Quantity::from_decimal_dp(filled_dec, size_precision)?;
1640 let price = Price::from_decimal_dp(price_dec, price_precision)?;
1641
1642 let mut report = OrderStatusReport::new(
1643 account_id,
1644 instrument.id(),
1645 None,
1646 venue_order_id,
1647 order_side.into(),
1648 OrderType::Limit,
1649 time_in_force,
1650 order_status,
1651 quantity,
1652 filled_qty,
1653 ts_event,
1654 ts_event,
1655 ts_init,
1656 None,
1657 );
1658 report.price = Some(price);
1659 report.expire_time = order
1660 .expiration
1661 .as_deref()
1662 .and_then(crate::execution::parse::parse_expiration_nanos)
1663 .map(UnixNanos::from);
1664
1665 if order_status == OrderStatus::Rejected {
1666 report.cancel_reason.clone_from(&status.reason);
1667 }
1668
1669 Ok(report)
1670}
1671
1672fn gtd_expiry_status(
1678 status: OrderStatus,
1679 order_type: PolymarketOrderType,
1680 expiration: Option<&str>,
1681 ts_event: UnixNanos,
1682) -> OrderStatus {
1683 const SECURITY_THRESHOLD_NS: u64 = 60_000_000_000;
1684
1685 if status != OrderStatus::Canceled || order_type != PolymarketOrderType::GTD {
1686 return status;
1687 }
1688
1689 let Some(expire_ns) = expiration.and_then(crate::execution::parse::parse_expiration_nanos)
1690 else {
1691 return status;
1692 };
1693
1694 if ts_event.as_u64().saturating_add(SECURITY_THRESHOLD_NS) >= expire_ns {
1695 OrderStatus::Expired
1696 } else {
1697 status
1698 }
1699}
1700
1701fn original_size_to_shares(
1712 original_size: Decimal,
1713 price: Decimal,
1714 side: PolymarketOrderSide,
1715 order_type: PolymarketOrderType,
1716) -> anyhow::Result<Decimal> {
1717 if side != PolymarketOrderSide::Buy
1718 || !matches!(
1719 order_type,
1720 PolymarketOrderType::FAK | PolymarketOrderType::FOK
1721 )
1722 {
1723 return Ok(original_size);
1724 }
1725
1726 original_size
1727 .checked_div(price)
1728 .context("order share quantity overflow")
1729}
1730
1731fn emit_tracked_order_status(
1737 report: &OrderStatusReport,
1738 context: &OrderContext,
1739 ts_event: UnixNanos,
1740 ctx: &WsDispatchContext<'_>,
1741) {
1742 let venue_order_id = report.venue_order_id;
1743 match report.order_status {
1744 OrderStatus::Accepted => ensure_accepted(context, venue_order_id, ts_event, ctx),
1745 OrderStatus::PartiallyFilled | OrderStatus::Filled => {
1746 ensure_accepted(context, venue_order_id, ts_event, ctx);
1747 }
1748 OrderStatus::Canceled => {
1749 ensure_accepted(context, venue_order_id, ts_event, ctx);
1750 emit_order_canceled(context, venue_order_id, ts_event, ctx);
1751 }
1752 OrderStatus::Expired => {
1753 ensure_accepted(context, venue_order_id, ts_event, ctx);
1754 emit_order_expired(context, venue_order_id, ts_event, ctx);
1755 }
1756 OrderStatus::Rejected => {
1757 let reason = report
1758 .cancel_reason
1759 .clone()
1760 .unwrap_or_else(|| "REJECTED".to_string());
1761
1762 emit_order_rejected(context, &reason, ts_event, ctx);
1763 }
1764 other => log::debug!("No order event for status {other:?} on {venue_order_id}"),
1765 }
1766}
1767
1768fn ensure_accepted(
1773 context: &OrderContext,
1774 venue_order_id: VenueOrderId,
1775 ts_event: UnixNanos,
1776 ctx: &WsDispatchContext<'_>,
1777) {
1778 if !ctx.order_contexts.mark_accepted(venue_order_id)
1779 || ctx.order_contexts.is_closed(venue_order_id)
1780 {
1781 return;
1782 }
1783
1784 let accepted = OrderAccepted::new(
1785 ctx.emitter.trader_id(),
1786 context.identity.strategy_id,
1787 context.identity.instrument_id,
1788 context.identity.client_order_id,
1789 venue_order_id,
1790 ctx.account_id,
1791 UUID4::new(),
1792 ts_event,
1793 ctx.clock.get_time_ns(),
1794 false,
1795 );
1796 ctx.emitter
1797 .send_order_event(OrderEventAny::Accepted(accepted));
1798}
1799
1800fn emit_order_filled(
1805 context: &OrderContext,
1806 fill: &FillReport,
1807 info: Option<IndexMap<Ustr, Ustr>>,
1808 ctx: &WsDispatchContext<'_>,
1809) {
1810 ensure_accepted(context, fill.venue_order_id, fill.ts_event, ctx);
1811
1812 if let Some(new_qty) = ctx.fill_tracker.buy_overfill_bump(&fill.venue_order_id) {
1813 emit_buy_overfill_update(context, fill.venue_order_id, new_qty, fill.ts_event, ctx);
1814 }
1815
1816 let filled = build_order_filled(context, fill, info, ctx);
1817
1818 ctx.settlement.note_leg_enqueued(&fill.trade_id);
1820 ctx.emitter.send_order_event(OrderEventAny::Filled(filled));
1821}
1822
1823fn build_order_filled(
1824 context: &OrderContext,
1825 fill: &FillReport,
1826 info: Option<IndexMap<Ustr, Ustr>>,
1827 ctx: &WsDispatchContext<'_>,
1828) -> OrderFilled {
1829 OrderFilled::new(
1830 ctx.emitter.trader_id(),
1831 context.identity.strategy_id,
1832 context.identity.instrument_id,
1833 context.identity.client_order_id,
1834 fill.venue_order_id,
1835 ctx.account_id,
1836 fill.trade_id,
1837 context.identity.order_side,
1838 context.identity.order_type,
1839 fill.last_qty,
1840 fill.last_px,
1841 get_pusd_currency(),
1842 fill.liquidity_side,
1843 UUID4::new(),
1844 fill.ts_event,
1845 fill.ts_init,
1846 false,
1847 fill.venue_position_id,
1848 Some(fill.commission),
1849 info,
1850 )
1851}
1852
1853pub(crate) fn emit_void_for_applied_fill(
1856 venue_trade_id: &str,
1857 fill: &OrderFilled,
1858 tracker: &OrderFillTrackerMap,
1859 emitter: &ExecutionEventEmitter,
1860 clock: &'static AtomicTime,
1861) {
1862 let ts_event = clock.get_time_ns();
1863
1864 let mut voided = OrderFillVoided::new(
1865 fill.trader_id,
1866 fill.strategy_id,
1867 fill.instrument_id,
1868 fill.client_order_id,
1869 fill.venue_order_id,
1870 fill.account_id,
1871 Ustr::from(&format!("{venue_trade_id}-FAILED-{}", fill.client_order_id)),
1872 fill.trade_id,
1873 fill.last_qty,
1874 fill.commission.clone(),
1875 fill.order_side,
1876 fill.order_type,
1877 fill.last_px,
1878 fill.currency.clone(),
1879 fill.liquidity_side,
1880 fill.position_id,
1881 Some(Ustr::from("FAILED")),
1882 fill.info.clone(),
1883 UUID4::new(),
1884 ts_event,
1885 clock.get_time_ns(),
1886 false,
1887 false,
1888 );
1889 voided.causation_id = Some(fill.event_id);
1890 tracker.reverse_fill(&fill.venue_order_id, fill.last_qty);
1891 emitter.send_order_event(OrderEventAny::FillVoided(voided));
1892}
1893
1894pub(crate) fn rest_trade_info(trade: &PolymarketTradeReport) -> Option<IndexMap<Ustr, Ustr>> {
1897 let value = serde_json::to_value(trade).ok()?;
1898 flatten_trade_value(&value)
1899}
1900
1901fn trade_fill_info(trade: &PolymarketUserTrade) -> Option<IndexMap<Ustr, Ustr>> {
1906 let value = serde_json::to_value(trade).ok()?;
1907 flatten_trade_value(&value)
1908}
1909
1910fn flatten_trade_value(value: &serde_json::Value) -> Option<IndexMap<Ustr, Ustr>> {
1911 let object = value.as_object()?;
1912 let mut info = IndexMap::with_capacity(object.len());
1913 for (key, val) in object {
1914 let val_str = match val {
1915 serde_json::Value::String(s) => s.clone(),
1916 other => other.to_string(),
1917 };
1918 info.insert(Ustr::from(key.as_str()), Ustr::from(val_str.as_str()));
1919 }
1920 Some(info)
1921}
1922
1923fn emit_buy_overfill_update(
1929 context: &OrderContext,
1930 venue_order_id: VenueOrderId,
1931 new_qty: Quantity,
1932 ts_event: UnixNanos,
1933 ctx: &WsDispatchContext<'_>,
1934) {
1935 let updated = OrderUpdated::new(
1936 ctx.emitter.trader_id(),
1937 context.identity.strategy_id,
1938 context.identity.instrument_id,
1939 context.identity.client_order_id,
1940 new_qty,
1941 UUID4::new(),
1942 ts_event,
1943 ctx.clock.get_time_ns(),
1944 false,
1945 Some(venue_order_id),
1946 Some(ctx.account_id),
1947 None,
1948 None,
1949 None,
1950 false,
1951 );
1952 ctx.emitter
1953 .send_order_event(OrderEventAny::Updated(updated));
1954}
1955
1956fn emit_terminal_quantity_update(
1958 context: &OrderContext,
1959 venue_order_id: VenueOrderId,
1960 quantity: Quantity,
1961 ts_event: UnixNanos,
1962 ctx: &WsDispatchContext<'_>,
1963) {
1964 let updated = OrderUpdated::new(
1965 ctx.emitter.trader_id(),
1966 context.identity.strategy_id,
1967 context.identity.instrument_id,
1968 context.identity.client_order_id,
1969 quantity,
1970 UUID4::new(),
1971 ts_event,
1972 ctx.clock.get_time_ns(),
1973 true,
1974 Some(venue_order_id),
1975 Some(ctx.account_id),
1976 None,
1977 None,
1978 None,
1979 false,
1980 );
1981 ctx.emitter
1982 .send_order_event(OrderEventAny::Updated(updated));
1983}
1984
1985fn emit_order_canceled(
1986 context: &OrderContext,
1987 venue_order_id: VenueOrderId,
1988 ts_event: UnixNanos,
1989 ctx: &WsDispatchContext<'_>,
1990) {
1991 let canceled = OrderCanceled::new(
1992 ctx.emitter.trader_id(),
1993 context.identity.strategy_id,
1994 context.identity.instrument_id,
1995 context.identity.client_order_id,
1996 UUID4::new(),
1997 ts_event,
1998 ctx.clock.get_time_ns(),
1999 false,
2000 Some(venue_order_id),
2001 Some(ctx.account_id),
2002 None,
2003 );
2004 ctx.emitter
2005 .send_order_event(OrderEventAny::Canceled(canceled));
2006}
2007
2008fn emit_order_expired(
2009 context: &OrderContext,
2010 venue_order_id: VenueOrderId,
2011 ts_event: UnixNanos,
2012 ctx: &WsDispatchContext<'_>,
2013) {
2014 let expired = OrderExpired::new(
2015 ctx.emitter.trader_id(),
2016 context.identity.strategy_id,
2017 context.identity.instrument_id,
2018 context.identity.client_order_id,
2019 UUID4::new(),
2020 ts_event,
2021 ctx.clock.get_time_ns(),
2022 false,
2023 Some(venue_order_id),
2024 Some(ctx.account_id),
2025 );
2026 ctx.emitter
2027 .send_order_event(OrderEventAny::Expired(expired));
2028}
2029
2030fn emit_order_rejected(
2031 context: &OrderContext,
2032 reason: &str,
2033 ts_event: UnixNanos,
2034 ctx: &WsDispatchContext<'_>,
2035) {
2036 let reason = sanitize_error_text(reason);
2037
2038 let rejected = OrderRejected::new(
2039 ctx.emitter.trader_id(),
2040 context.identity.strategy_id,
2041 context.identity.instrument_id,
2042 context.identity.client_order_id,
2043 ctx.account_id,
2044 Ustr::from(&reason),
2045 UUID4::new(),
2046 ts_event,
2047 ctx.clock.get_time_ns(),
2048 false,
2049 is_post_only_crossing(&reason),
2050 );
2051 ctx.emitter
2052 .send_order_event(OrderEventAny::Rejected(rejected));
2053}
2054
2055#[cfg(test)]
2056mod tests {
2057 use futures_util::FutureExt;
2058 use nautilus_common::messages::{ExecutionEvent, ExecutionReport};
2059 use nautilus_core::{Params, time::AtomicTime};
2060 use nautilus_live::execution::context::OrderIdentity;
2061 use nautilus_model::{
2062 enums::{AccountType, LiquiditySide, OrderSide, OrderStatus},
2063 events::OrderEventAny,
2064 identifiers::{ClientOrderId, InstrumentId, StrategyId, TraderId},
2065 orders::{Order, builder::OrderTestBuilder},
2066 types::{Currency, Money},
2067 };
2068 use rstest::rstest;
2069 use rust_decimal_macros::dec;
2070
2071 use super::*;
2072 use crate::{
2073 common::enums::{PolymarketLiquiditySide, PolymarketOutcome, PolymarketTradeStatus},
2074 execution::settlement::{
2075 admission::AdmittedTrade,
2076 registry::tests::{settlement_state, trade_hard_fault},
2077 state::SettlementState,
2078 },
2079 http::{
2080 models::GammaMarket,
2081 parse::{create_instrument_from_def, parse_gamma_market},
2082 },
2083 };
2084
2085 fn register_context(
2087 order_contexts: &OrderContextRegistry,
2088 venue_order_id: VenueOrderId,
2089 instrument_id: InstrumentId,
2090 client_order_id: &str,
2091 ) {
2092 order_contexts.register_context(
2093 venue_order_id,
2094 OrderContext {
2095 identity: OrderIdentity {
2096 client_order_id: ClientOrderId::from(client_order_id),
2097 strategy_id: StrategyId::from("S-001"),
2098 instrument_id,
2099 order_side: OrderSide::Buy,
2100 order_type: OrderType::Limit,
2101 },
2102 quantity: Quantity::from("10"),
2103 price: Some(Price::from("0.50")),
2104 trigger_price: None,
2105 trigger_type: None,
2106 time_in_force: TimeInForce::Gtc,
2107 is_post_only: false,
2108 is_reduce_only: false,
2109 is_quote_quantity: false,
2110 },
2111 );
2112 }
2113
2114 fn load<T: serde::de::DeserializeOwned>(filename: &str) -> T {
2115 let path = format!("test_data/{filename}");
2116 let content = std::fs::read_to_string(path).expect("Failed to read test data");
2117 serde_json::from_str(&content).expect("Failed to parse test data")
2118 }
2119
2120 fn test_instrument() -> InstrumentAny {
2121 let market: GammaMarket = load("gamma_market.json");
2122 let defs = parse_gamma_market(&market).unwrap();
2123 create_instrument_from_def(&defs[0], UnixNanos::from(1_000_000_000u64)).unwrap()
2124 }
2125
2126 fn bind_instrument(
2127 mut instrument: InstrumentAny,
2128 market: &str,
2129 outcome: PolymarketOutcome,
2130 ) -> InstrumentAny {
2131 let InstrumentAny::BinaryOption(binary) = &mut instrument else {
2132 panic!("expected BinaryOption test instrument");
2133 };
2134
2135 binary.outcome = Some(Ustr::from(outcome.as_str()));
2136 let mut info = binary.info.as_deref().cloned().unwrap_or_default();
2137 info.insert(
2138 "condition_id".to_string(),
2139 serde_json::Value::String(market.to_string()),
2140 );
2141 binary.info = Some(Params::new(info));
2142 instrument
2143 }
2144
2145 fn instrument_for_trade(trade: &PolymarketUserTrade) -> InstrumentAny {
2146 bind_instrument(test_instrument(), trade.market.as_str(), trade.outcome)
2147 }
2148
2149 fn set_taker_fee_rate(instrument: &mut InstrumentAny, rate: Decimal) {
2150 set_taker_fee_schedule(instrument, rate, Decimal::ONE);
2151 }
2152
2153 fn set_taker_fee_schedule(instrument: &mut InstrumentAny, rate: Decimal, exponent: Decimal) {
2154 let InstrumentAny::BinaryOption(binary) = instrument else {
2155 panic!("expected binary option test instrument");
2156 };
2157
2158 let mut info = binary.info.as_deref().cloned().unwrap_or_default();
2159 info.insert(
2160 "fee_schedule".into(),
2161 serde_json::json!({
2162 "exponent": exponent.to_string(),
2163 "rate": rate.to_string(),
2164 "takerOnly": true,
2165 "rebateRate": "0",
2166 }),
2167 );
2168 binary.info = Some(Params::new(info));
2169 }
2170
2171 fn test_emitter() -> ExecutionEventEmitter {
2172 ExecutionEventEmitter::new(
2173 nautilus_core::time::get_atomic_clock_realtime(),
2174 TraderId::from("TESTER-001"),
2175 AccountId::from("POLY-001"),
2176 AccountType::Cash,
2177 Some(Currency::pUSD()),
2178 )
2179 }
2180
2181 #[rstest]
2182 #[case::matching(|_: &mut PolymarketUserTrade, _: &mut InstrumentAny| {}, false, dec!(0))]
2183 #[case::quantity(|trade: &mut PolymarketUserTrade, _: &mut InstrumentAny| {
2184 trade.size = "26.0".to_string();
2185 trade.maker_orders[0].matched_amount = dec!(26);
2186 }, true, dec!(0))]
2187 #[case::price(|trade: &mut PolymarketUserTrade, _: &mut InstrumentAny| {
2188 trade.price = "0.6".to_string();
2189 trade.maker_orders[0].price = dec!(0.6);
2190 }, true, dec!(0))]
2191 #[case::side(|trade: &mut PolymarketUserTrade, _: &mut InstrumentAny| trade.side = PolymarketOrderSide::Sell, true, dec!(0))]
2192 #[case::fee_schedule(|_: &mut PolymarketUserTrade, instrument: &mut InstrumentAny| set_taker_fee_rate(instrument, dec!(0.01)), false, dec!(0))]
2193 fn test_dispatch_conflicting_trade_after_applied_fill(
2194 #[case] change: fn(&mut PolymarketUserTrade, &mut InstrumentAny),
2195 #[case] conflicts: bool,
2196 #[case] commission: Decimal,
2197 ) {
2198 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
2199 trade.status = PolymarketTradeStatus::Matched;
2200 let instrument = instrument_for_trade(&trade);
2201 let token_instruments = AtomicMap::new();
2202 token_instruments.insert(trade.asset_id, instrument.clone());
2203 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
2204 let fill_tracker = OrderFillTrackerMap::new();
2205 fill_tracker.register(
2206 venue_order_id,
2207 Quantity::from("100.000000"),
2208 OrderSide::Buy,
2209 instrument.id(),
2210 instrument.size_precision(),
2211 instrument.price_precision(),
2212 );
2213 let pending_submits = PendingSubmitTracker::default();
2214 let order_contexts = OrderContextRegistry::default();
2215 register_context(
2216 &order_contexts,
2217 venue_order_id,
2218 instrument.id(),
2219 "O-CONFLICT",
2220 );
2221 order_contexts.mark_accepted(venue_order_id);
2222 let mut emitter = test_emitter();
2223 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
2224 emitter.set_sender(sender);
2225 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
2226 settlement.begin_session();
2227 settlement.note_order_submitted(venue_order_id);
2228
2229 let ctx = WsDispatchContext {
2230 signer_type: PolymarketSignerType::Owner,
2231 token_instruments: &token_instruments,
2232 fill_tracker: &fill_tracker,
2233 settlement: &settlement,
2234 pending_submits: &pending_submits,
2235 order_contexts: &order_contexts,
2236 emitter: &emitter,
2237 account_id: AccountId::from("POLY-001"),
2238 clock: nautilus_core::time::get_atomic_clock_realtime(),
2239 user_address: trade.maker_address.as_str(),
2240 user_api_key: trade.owner.as_str(),
2241 };
2242
2243 let mut state = WsDispatchState::default();
2244 dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
2245
2246 let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = receiver.try_recv().unwrap()
2247 else {
2248 panic!("expected original fill");
2249 };
2250
2251 settlement.observe_fill_applied(&fill);
2252 let mut incoming = trade.clone();
2253 incoming.status = PolymarketTradeStatus::Confirmed;
2254 let mut updated_instrument = instrument;
2255 change(&mut incoming, &mut updated_instrument);
2256 token_instruments.insert(trade.asset_id, updated_instrument);
2257 let admitted =
2258 admit_trade_evidence(TradeEvidence::Stream(&incoming), &ctx.admission_context())
2259 .unwrap();
2260
2261 dispatch_user_message(&UserWsMessage::Trade(incoming), &ctx, &mut state);
2262
2263 assert_eq!(fill.trade_id, TradeId::from(trade.id.as_str()));
2264 assert_eq!(fill.last_qty, Quantity::from("25.000000"));
2265 assert_eq!(fill.last_px.as_decimal(), dec!(0.5));
2266 assert_eq!(fill.order_side, OrderSide::Buy);
2267 assert_eq!(fill.commission, Some(Money::zero(Currency::pUSD())));
2268 assert_eq!(admitted.legs[0].commission.as_decimal(), commission);
2269 assert!(receiver.try_recv().is_err());
2270 assert_eq!(
2271 settlement_state(&settlement, &trade.id),
2272 Some(if conflicts {
2273 SettlementState::Quarantined
2274 } else {
2275 SettlementState::StreamConfirmed
2276 })
2277 );
2278 assert_eq!(
2279 settlement.pending_resolutions(),
2280 if conflicts {
2281 vec![trade.id.clone()]
2282 } else {
2283 vec![]
2284 }
2285 );
2286 assert_eq!(trade_hard_fault(&settlement, &trade.id), None);
2287 assert_eq!(
2288 settlement.ensure_resolved(None, "mass status").is_ok(),
2289 !conflicts
2290 );
2291 }
2292
2293 #[rstest]
2294 #[case::refresh_before_stream_confirm(true, false)]
2295 #[case::refresh_after_stream_confirm(false, false)]
2296 #[case::refresh_exponent(true, true)]
2297 fn test_fee_schedule_refresh_preserves_admitted_taker_commission(
2298 #[case] refresh_before_stream: bool,
2299 #[case] refresh_exponent: bool,
2300 ) {
2301 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
2302 trade.status = PolymarketTradeStatus::Matched;
2303 let mut instrument = instrument_for_trade(&trade);
2304 set_taker_fee_rate(&mut instrument, dec!(0.0721));
2305 let token_instruments = AtomicMap::new();
2306 token_instruments.insert(trade.asset_id, instrument.clone());
2307 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
2308 let fill_tracker = OrderFillTrackerMap::new();
2309 fill_tracker.register(
2310 venue_order_id,
2311 Quantity::from("100.000000"),
2312 OrderSide::Buy,
2313 instrument.id(),
2314 instrument.size_precision(),
2315 instrument.price_precision(),
2316 );
2317 let pending_submits = PendingSubmitTracker::default();
2318 let order_contexts = OrderContextRegistry::default();
2319 register_context(
2320 &order_contexts,
2321 venue_order_id,
2322 instrument.id(),
2323 "O-FEE-BASIS",
2324 );
2325 order_contexts.mark_accepted(venue_order_id);
2326 let mut emitter = test_emitter();
2327 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
2328 emitter.set_sender(sender);
2329 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
2330 settlement.begin_session();
2331 settlement.note_order_submitted(venue_order_id);
2332
2333 let ctx = WsDispatchContext {
2334 signer_type: PolymarketSignerType::Owner,
2335 token_instruments: &token_instruments,
2336 fill_tracker: &fill_tracker,
2337 settlement: &settlement,
2338 pending_submits: &pending_submits,
2339 order_contexts: &order_contexts,
2340 emitter: &emitter,
2341 account_id: AccountId::from("POLY-001"),
2342 clock: nautilus_core::time::get_atomic_clock_realtime(),
2343 user_address: trade.maker_address.as_str(),
2344 user_api_key: trade.owner.as_str(),
2345 };
2346
2347 let mut state = WsDispatchState::default();
2348
2349 dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
2350
2351 let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = receiver.try_recv().unwrap()
2352 else {
2353 panic!("expected original fill");
2354 };
2355
2356 settlement.observe_fill_applied(&fill);
2357
2358 let refresh = |rate| {
2359 let mut updated = instrument.clone();
2360 set_taker_fee_rate(&mut updated, rate);
2361 token_instruments.insert(trade.asset_id, updated);
2362 };
2363
2364 if refresh_before_stream {
2365 if refresh_exponent {
2366 let mut updated = instrument.clone();
2367 set_taker_fee_schedule(&mut updated, dec!(0.0721), Decimal::TWO);
2368 token_instruments.insert(trade.asset_id, updated);
2369 } else {
2370 refresh(dec!(0.01));
2371 }
2372 }
2373
2374 let mut confirmed = trade.clone();
2375 confirmed.status = PolymarketTradeStatus::Confirmed;
2376 dispatch_user_message(&UserWsMessage::Trade(confirmed.clone()), &ctx, &mut state);
2377
2378 if !refresh_before_stream {
2379 refresh(dec!(0.01));
2380 }
2381
2382 let admitted_stream =
2383 admit_trade_evidence(TradeEvidence::Stream(&confirmed), &ctx.admission_context())
2384 .unwrap();
2385 assert_eq!(
2386 admitted_stream.legs[0].commission.as_decimal(),
2387 dec!(0.45062)
2388 );
2389
2390 let mut rest: PolymarketTradeReport = load("http_trade_report.json");
2391 rest.id = trade.id.clone();
2392 rest.taker_order_id = trade.taker_order_id.clone();
2393 apply_rest_trade_evidence(&rest, &ctx, &mut state);
2394 apply_rest_trade_evidence(&rest, &ctx, &mut state);
2395 assert_eq!(
2396 settlement_state(&settlement, &trade.id),
2397 Some(SettlementState::RestConfirmed)
2398 );
2399 assert_eq!(trade_hard_fault(&settlement, &trade.id), None);
2400 assert!(settlement.pending_resolutions().is_empty());
2401 assert!(settlement.ensure_resolved(None, "mass status").is_ok());
2402 let admitted =
2403 admit_trade_evidence(TradeEvidence::Rest(&rest), &ctx.admission_context()).unwrap();
2404 let report = settlement
2405 .build_fill_report(&trade.id, &admitted.legs[0], UnixNanos::from(1))
2406 .unwrap();
2407 assert_eq!(report.commission.as_decimal(), dec!(0.45062));
2408 assert_eq!(report.last_qty, fill.last_qty);
2409 assert_eq!(report.last_px, fill.last_px);
2410
2411 let mut fresh = trade.clone();
2412 fresh.id = format!("{}-fresh", trade.id);
2413 fresh.taker_order_id = format!("{}-fresh", trade.taker_order_id);
2414 fresh.status = PolymarketTradeStatus::Matched;
2415 let fresh_order_id = VenueOrderId::from(fresh.taker_order_id.as_str());
2416 fill_tracker.register(
2417 fresh_order_id,
2418 Quantity::from("100.000000"),
2419 OrderSide::Buy,
2420 instrument.id(),
2421 instrument.size_precision(),
2422 instrument.price_precision(),
2423 );
2424 register_context(
2425 &order_contexts,
2426 fresh_order_id,
2427 instrument.id(),
2428 "O-FEE-FRESH",
2429 );
2430 order_contexts.mark_accepted(fresh_order_id);
2431 settlement.note_order_submitted(fresh_order_id);
2432 dispatch_user_message(&UserWsMessage::Trade(fresh), &ctx, &mut state);
2433
2434 let ExecutionEvent::Order(OrderEventAny::Filled(fresh_fill)) = receiver.try_recv().unwrap()
2435 else {
2436 panic!("expected fresh fill");
2437 };
2438
2439 assert_eq!(fill.trade_id, TradeId::from(trade.id.as_str()));
2440 assert_eq!(fill.last_qty, Quantity::from("25.000000"));
2441 assert_eq!(fill.last_px.as_decimal(), dec!(0.5));
2442 assert_eq!(fill.commission.unwrap().as_decimal(), dec!(0.45062));
2443 assert_ne!(dec!(0.450625), fill.commission.unwrap().as_decimal());
2444
2445 let fresh_commission = if refresh_exponent {
2446 dec!(0.11265)
2447 } else {
2448 dec!(0.0625)
2449 };
2450
2451 assert_eq!(
2452 fresh_fill.commission.unwrap().as_decimal(),
2453 fresh_commission
2454 );
2455 assert!(receiver.try_recv().is_err());
2456 assert_eq!(
2457 fill_tracker.get_cumulative_filled(&venue_order_id),
2458 Some(fill.last_qty)
2459 );
2460 }
2461
2462 #[rstest]
2463 fn test_fee_schedule_refresh_keeps_maker_commission_zero() {
2464 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
2465 trade.status = PolymarketTradeStatus::Matched;
2466 trade.trader_side = PolymarketLiquiditySide::Maker;
2467 let mut instrument = instrument_for_trade(&trade);
2468 set_taker_fee_rate(&mut instrument, dec!(0.0721));
2469 let token_instruments = AtomicMap::new();
2470 token_instruments.insert(trade.asset_id, instrument.clone());
2471 let maker_order_id = VenueOrderId::from(trade.maker_orders[0].order_id.as_str());
2472 let fill_tracker = OrderFillTrackerMap::new();
2473 fill_tracker.register(
2474 maker_order_id,
2475 Quantity::from("100.000000"),
2476 OrderSide::Buy,
2477 instrument.id(),
2478 instrument.size_precision(),
2479 instrument.price_precision(),
2480 );
2481 let pending_submits = PendingSubmitTracker::default();
2482 let order_contexts = OrderContextRegistry::default();
2483 register_context(
2484 &order_contexts,
2485 maker_order_id,
2486 instrument.id(),
2487 "O-MAKER-FEE",
2488 );
2489 order_contexts.mark_accepted(maker_order_id);
2490 let mut emitter = test_emitter();
2491 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
2492 emitter.set_sender(sender);
2493 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
2494 settlement.begin_session();
2495 settlement.note_order_submitted(maker_order_id);
2496 let maker_address = trade.maker_orders[0].maker_address.clone();
2497
2498 let ctx = WsDispatchContext {
2499 signer_type: PolymarketSignerType::Owner,
2500 token_instruments: &token_instruments,
2501 fill_tracker: &fill_tracker,
2502 settlement: &settlement,
2503 pending_submits: &pending_submits,
2504 order_contexts: &order_contexts,
2505 emitter: &emitter,
2506 account_id: AccountId::from("POLY-001"),
2507 clock: nautilus_core::time::get_atomic_clock_realtime(),
2508 user_address: maker_address.as_str(),
2509 user_api_key: "ffffffff-ffff-ffff-ffff-ffffffffffff",
2510 };
2511
2512 let mut state = WsDispatchState::default();
2513
2514 dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
2515
2516 let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = receiver.try_recv().unwrap()
2517 else {
2518 panic!("expected maker fill");
2519 };
2520
2521 settlement.observe_fill_applied(&fill);
2522 set_taker_fee_rate(&mut instrument, dec!(0.01));
2523 token_instruments.insert(trade.asset_id, instrument);
2524 let mut confirmed = trade.clone();
2525 confirmed.status = PolymarketTradeStatus::Confirmed;
2526 dispatch_user_message(&UserWsMessage::Trade(confirmed), &ctx, &mut state);
2527
2528 assert!(fill.commission.unwrap().is_zero());
2529 assert!(receiver.try_recv().is_err());
2530 assert_eq!(
2531 settlement_state(&settlement, &trade.id),
2532 Some(SettlementState::StreamConfirmed)
2533 );
2534 assert_eq!(trade_hard_fault(&settlement, &trade.id), None);
2535 }
2536
2537 #[rstest]
2538 #[case::unknown(false, false, false)]
2539 #[case::applied_unowned_rest(true, false, false)]
2540 #[case::applied_matching_rest(true, false, true)]
2541 #[case::settled_unowned_rest(true, true, false)]
2542 #[case::settled_matching_rest(true, true, true)]
2543 fn test_dispatch_trade_missing_all_owned_legs(
2544 #[case] known: bool,
2545 #[case] rest_settled: bool,
2546 #[case] rest_owned: bool,
2547 ) {
2548 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
2549 trade.trader_side = PolymarketLiquiditySide::Maker;
2550 trade.side = PolymarketOrderSide::Sell;
2551 trade.status = PolymarketTradeStatus::Matched;
2552 let user_address = trade.maker_orders[0].maker_address.clone();
2553 let api_key = trade.maker_orders[0].owner.clone();
2554 let venue_order_id = VenueOrderId::from(trade.maker_orders[0].order_id.as_str());
2555 let instrument = instrument_for_trade(&trade);
2556 let token_instruments = AtomicMap::new();
2557 token_instruments.insert(trade.asset_id, instrument.clone());
2558 let fill_tracker = OrderFillTrackerMap::new();
2559 fill_tracker.register(
2560 venue_order_id,
2561 Quantity::from("100.000000"),
2562 OrderSide::Buy,
2563 instrument.id(),
2564 instrument.size_precision(),
2565 instrument.price_precision(),
2566 );
2567 let pending_submits = PendingSubmitTracker::default();
2568 let order_contexts = OrderContextRegistry::default();
2569 register_context(
2570 &order_contexts,
2571 venue_order_id,
2572 instrument.id(),
2573 "O-MISSING-MAKER",
2574 );
2575 order_contexts.mark_accepted(venue_order_id);
2576 let mut emitter = test_emitter();
2577 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
2578 emitter.set_sender(sender);
2579 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
2580 settlement.begin_session();
2581 settlement.note_order_submitted(venue_order_id);
2582
2583 let ctx = WsDispatchContext {
2584 signer_type: PolymarketSignerType::Owner,
2585 token_instruments: &token_instruments,
2586 fill_tracker: &fill_tracker,
2587 settlement: &settlement,
2588 pending_submits: &pending_submits,
2589 order_contexts: &order_contexts,
2590 emitter: &emitter,
2591 account_id: AccountId::from("POLY-001"),
2592 clock: nautilus_core::time::get_atomic_clock_realtime(),
2593 user_address: user_address.as_str(),
2594 user_api_key: api_key.as_str(),
2595 };
2596
2597 let mut state = WsDispatchState::default();
2598
2599 if known {
2600 dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
2601
2602 let ExecutionEvent::Order(OrderEventAny::Filled(fill)) = receiver.try_recv().unwrap()
2603 else {
2604 panic!("expected original maker fill");
2605 };
2606
2607 assert_eq!(fill.venue_order_id, venue_order_id);
2608 assert_eq!(fill.liquidity_side, LiquiditySide::Maker);
2609 settlement.observe_fill_applied(&fill);
2610 }
2611
2612 if rest_settled {
2613 let mut admitted =
2614 admit_trade_evidence(TradeEvidence::Stream(&trade), &ctx.admission_context())
2615 .unwrap();
2616 admitted.status = PolymarketTradeStatus::Confirmed;
2617 settlement.admit_rest_result(&admitted);
2618 }
2619
2620 let mut rest: PolymarketTradeReport = load("http_trade_report.json");
2621 rest.id = trade.id.clone();
2622 rest.taker_order_id = trade.taker_order_id.clone();
2623 rest.trader_side = trade.trader_side;
2624 rest.side = trade.side;
2625 rest.maker_orders = trade.maker_orders.clone();
2626 for maker in &mut rest.maker_orders {
2627 maker.side = Some(PolymarketOrderSide::Buy);
2628 }
2629
2630 if !rest_owned {
2631 rest.maker_orders.clear();
2632 }
2633
2634 trade.maker_orders.clear();
2635 trade.status = PolymarketTradeStatus::Confirmed;
2636 assert!(settlement.resolution_requested().now_or_never().is_none());
2637
2638 dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
2639
2640 assert_eq!(
2641 settlement.resolution_requested().now_or_never().is_some(),
2642 known
2643 );
2644 assert!(receiver.try_recv().is_err());
2645 assert_eq!(settlement.record_count(), usize::from(known));
2646
2647 let expected = known.then_some(if rest_settled {
2648 SettlementState::RestConfirmed
2649 } else {
2650 SettlementState::Quarantined
2651 });
2652
2653 assert_eq!(settlement_state(&settlement, &trade.id), expected);
2654 assert_eq!(
2655 settlement.pending_resolutions(),
2656 if known {
2657 vec![trade.id.clone()]
2658 } else {
2659 vec![]
2660 }
2661 );
2662 assert_eq!(trade_hard_fault(&settlement, &trade.id), None);
2663 assert_eq!(
2664 settlement.ensure_resolved(None, "mass status").is_ok(),
2665 !known
2666 );
2667
2668 if known {
2669 apply_rest_trade_evidence(&rest, &ctx, &mut state);
2670
2671 assert!(receiver.try_recv().is_err());
2672 assert_eq!(
2673 settlement_state(&settlement, &trade.id),
2674 Some(if rest_settled || rest_owned {
2675 SettlementState::RestConfirmed
2676 } else {
2677 SettlementState::Quarantined
2678 })
2679 );
2680 assert_eq!(
2681 settlement.pending_resolutions(),
2682 if rest_owned {
2683 vec![]
2684 } else {
2685 vec![trade.id.clone()]
2686 }
2687 );
2688 assert_eq!(trade_hard_fault(&settlement, &trade.id), None);
2689 assert_eq!(
2690 settlement.ensure_resolved(None, "mass status").is_ok(),
2691 rest_owned
2692 );
2693 assert_eq!(
2694 fill_tracker.get_cumulative_filled(&venue_order_id),
2695 Some(Quantity::from("25.000000"))
2696 );
2697 }
2698 }
2699
2700 #[rstest]
2701 fn test_emit_order_rejected_uses_bounded_clean_reason() {
2702 let instrument = test_instrument();
2703 let token_instruments = AtomicMap::new();
2704 let fill_tracker = OrderFillTrackerMap::new();
2705 let pending_submits = PendingSubmitTracker::default();
2706 let order_contexts = OrderContextRegistry::default();
2707 let mut emitter = test_emitter();
2708 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
2709
2710 emitter.set_sender(sender);
2711
2712 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
2713 settlement.mark_live();
2714
2715 let ctx = WsDispatchContext {
2716 signer_type: PolymarketSignerType::Owner,
2717 token_instruments: &token_instruments,
2718 fill_tracker: &fill_tracker,
2719 settlement: &settlement,
2720 pending_submits: &pending_submits,
2721 order_contexts: &order_contexts,
2722 emitter: &emitter,
2723 account_id: AccountId::from("POLY-001"),
2724 clock: nautilus_core::time::get_atomic_clock_realtime(),
2725 user_address: "0xtest",
2726 user_api_key: "test-key",
2727 };
2728 let context = OrderContext {
2729 identity: OrderIdentity {
2730 client_order_id: ClientOrderId::from("O-WS-REJECT"),
2731 strategy_id: StrategyId::from("S-001"),
2732 instrument_id: instrument.id(),
2733 order_side: OrderSide::Buy,
2734 order_type: OrderType::Limit,
2735 },
2736 quantity: Quantity::from("10"),
2737 price: Some(Price::from("0.50")),
2738 trigger_price: None,
2739 trigger_type: None,
2740 time_in_force: TimeInForce::Gtc,
2741 is_post_only: false,
2742 is_reduce_only: false,
2743 is_quote_quantity: false,
2744 };
2745
2746 emit_order_rejected(
2747 &context,
2748 " invalid post-only order:\norder crosses book ",
2749 UnixNanos::from(1_000_000_000),
2750 &ctx,
2751 );
2752
2753 match receiver.try_recv().expect("expected rejected event") {
2754 ExecutionEvent::Order(OrderEventAny::Rejected(event)) => {
2755 assert_eq!(event.reason, "invalid post-only order: order crosses book");
2756 assert!(event.due_post_only);
2757 }
2758 other => panic!("expected rejected event, was {other:?}"),
2759 }
2760 }
2761
2762 #[rstest]
2763 #[case::empty_price("", "1.01", "0")]
2764 #[case::zero_price("0", "1.01", "0")]
2765 #[case::malformed("bad", "100", "0")]
2766 #[case::too_precise("0.50000000000000000000000000001", "100", "0")]
2767 #[case::quantity_overflow("0.5", "79228162514264337593543950335", "0")]
2768 #[case::filled_overflow("0.5", "100", "79228162514264337593543950335")]
2769 fn test_ws_order_report_rejects_invalid_values(
2770 #[case] price: &str,
2771 #[case] quantity: &str,
2772 #[case] filled: &str,
2773 ) {
2774 let mut order: PolymarketUserOrder = load("ws_user_order_placement.json");
2775 order.price = price.into();
2776 order.original_size = quantity.into();
2777 order.size_matched = filled.into();
2778 assert!(
2779 build_ws_order_status_report(
2780 &order,
2781 order.status.as_ref().unwrap(),
2782 order.order_type.unwrap(),
2783 &test_instrument(),
2784 AccountId::from("POLY-001"),
2785 UnixNanos::default(),
2786 UnixNanos::default()
2787 )
2788 .is_err()
2789 );
2790 }
2791
2792 #[rstest]
2793 fn test_ws_fok_order_report_rejects_share_overflow() {
2794 let mut order: PolymarketUserOrder = load("ws_user_order_fok_buy_pusd_size.json");
2795 order.original_size = Decimal::MAX.to_string();
2796 order.price = "0.5".into();
2797 let result = build_ws_order_status_report(
2798 &order,
2799 order.status.as_ref().unwrap(),
2800 PolymarketOrderType::FOK,
2801 &test_instrument(),
2802 AccountId::from("POLY-001"),
2803 UnixNanos::default(),
2804 UnixNanos::default(),
2805 );
2806
2807 assert_eq!(
2808 result.unwrap_err().to_string(),
2809 "order share quantity overflow"
2810 );
2811 }
2812
2813 #[rstest]
2814 fn test_build_ws_order_status_report() {
2815 let order: PolymarketUserOrder = load("ws_user_order_placement.json");
2816 let instrument = test_instrument();
2817 let ts_event = UnixNanos::from(1_000_000_000u64);
2818 let ts_init = UnixNanos::from(2_000_000_000u64);
2819
2820 let report = build_ws_order_status_report(
2821 &order,
2822 order.status.as_ref().unwrap(),
2823 order.order_type.unwrap(),
2824 &instrument,
2825 AccountId::from("POLY-001"),
2826 ts_event,
2827 ts_init,
2828 )
2829 .unwrap();
2830
2831 assert_eq!(report.order_side, Some(OrderSide::Buy));
2832 assert_eq!(report.order_type, OrderType::Limit);
2833 assert_eq!(report.quantity.as_decimal(), dec!(100));
2835 assert_eq!(
2836 report.price.map(|price| price.as_decimal()),
2837 Some(dec!(0.5))
2838 );
2839 assert_eq!(report.ts_accepted, ts_event);
2840 assert_eq!(report.ts_init, ts_init);
2841 }
2842
2843 #[rstest]
2844 fn test_build_ws_order_status_report_venue_cancel_maps_to_canceled() {
2845 let order: PolymarketUserOrder = load("ws_user_order_venue_cancel.json");
2846 let instrument = test_instrument();
2847 let ts_event = UnixNanos::from(1_000_000_000u64);
2848 let ts_init = UnixNanos::from(2_000_000_000u64);
2849
2850 let report = build_ws_order_status_report(
2851 &order,
2852 order.status.as_ref().unwrap(),
2853 order.order_type.unwrap(),
2854 &instrument,
2855 AccountId::from("POLY-001"),
2856 ts_event,
2857 ts_init,
2858 )
2859 .unwrap();
2860
2861 assert_eq!(report.order_status, OrderStatus::Canceled);
2862 }
2863
2864 #[rstest]
2865 #[case::before_window(939_000_000_000, OrderStatus::Canceled)]
2866 #[case::window_start(940_000_000_000, OrderStatus::Expired)]
2867 #[case::security_threshold(999_000_000_000, OrderStatus::Expired)]
2868 #[case::at_expiry(1_000_000_000_000, OrderStatus::Expired)]
2869 #[case::after_expiry(1_000_000_001_000, OrderStatus::Expired)]
2870 fn test_build_ws_order_status_report_gtd_expiry_maps_to_expired(
2871 #[case] ts_event: u64,
2872 #[case] expected: OrderStatus,
2873 ) {
2874 let mut order: PolymarketUserOrder = load("ws_user_order_venue_cancel.json");
2875 order.order_type = Some(PolymarketOrderType::GTD);
2876 order.expiration = Some("1000".to_string());
2877 let instrument = test_instrument();
2878
2879 let report = build_ws_order_status_report(
2880 &order,
2881 order.status.as_ref().unwrap(),
2882 order.order_type.unwrap(),
2883 &instrument,
2884 AccountId::from("POLY-001"),
2885 UnixNanos::from(ts_event),
2886 UnixNanos::from(2_000_000_000u64),
2887 )
2888 .unwrap();
2889
2890 assert_eq!(report.order_status, expected);
2891 assert_eq!(
2892 report.expire_time,
2893 Some(UnixNanos::from(1_000_000_000_000u64))
2894 );
2895 }
2896
2897 #[rstest]
2898 #[case::gtc_in_window(PolymarketOrderType::GTC, Some("1000"))]
2899 #[case::gtd_zero_expiration(PolymarketOrderType::GTD, Some("0"))]
2900 #[case::gtd_missing_expiration(PolymarketOrderType::GTD, None)]
2901 fn test_build_ws_order_status_report_non_expiry_cancel_stays_canceled(
2902 #[case] order_type: PolymarketOrderType,
2903 #[case] expiration: Option<&str>,
2904 ) {
2905 let mut order: PolymarketUserOrder = load("ws_user_order_venue_cancel.json");
2906 order.order_type = Some(order_type);
2907 order.expiration = expiration.map(str::to_string);
2908 let instrument = test_instrument();
2909
2910 let report = build_ws_order_status_report(
2911 &order,
2912 order.status.as_ref().unwrap(),
2913 order.order_type.unwrap(),
2914 &instrument,
2915 AccountId::from("POLY-001"),
2916 UnixNanos::from(999_000_000_000u64),
2917 UnixNanos::from(2_000_000_000u64),
2918 )
2919 .unwrap();
2920
2921 assert_eq!(report.order_status, OrderStatus::Canceled);
2922 }
2923
2924 #[rstest]
2925 fn test_reemit_terminal_expiry_emits_expired() {
2926 let mut order: PolymarketUserOrder = load("ws_user_order_venue_cancel.json");
2927 order.order_type = Some(PolymarketOrderType::GTD);
2928 order.expiration = Some("1000".to_string());
2929 let instrument = test_instrument();
2930 let report = build_ws_order_status_report(
2931 &order,
2932 order.status.as_ref().unwrap(),
2933 PolymarketOrderType::GTD,
2934 &instrument,
2935 AccountId::from("POLY-001"),
2936 UnixNanos::from(1_000_000_000_000u64),
2937 UnixNanos::from(2_000_000_000u64),
2938 )
2939 .unwrap();
2940 let venue_order_id = report.venue_order_id;
2941 let mut state = WsDispatchState::default();
2942 state.record_terminal_cancel_report(report);
2943
2944 let token_instruments = AtomicMap::new();
2945 let fill_tracker = OrderFillTrackerMap::new();
2946 let pending_submits = PendingSubmitTracker::default();
2947 let order_contexts = OrderContextRegistry::default();
2948
2949 let context = OrderContext {
2950 identity: OrderIdentity {
2951 client_order_id: ClientOrderId::from("O-GTD-EXPIRE"),
2952 strategy_id: StrategyId::from("S-001"),
2953 instrument_id: instrument.id(),
2954 order_side: OrderSide::Buy,
2955 order_type: OrderType::Limit,
2956 },
2957 quantity: Quantity::from("10"),
2958 price: Some(Price::from("0.50")),
2959 trigger_price: None,
2960 trigger_type: None,
2961 time_in_force: TimeInForce::Gtd,
2962 is_post_only: false,
2963 is_reduce_only: false,
2964 is_quote_quantity: false,
2965 };
2966
2967 order_contexts.register_context(venue_order_id, context);
2968 let mut emitter = test_emitter();
2969 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
2970 emitter.set_sender(sender);
2971 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
2972
2973 let ctx = WsDispatchContext {
2974 signer_type: PolymarketSignerType::Owner,
2975 token_instruments: &token_instruments,
2976 fill_tracker: &fill_tracker,
2977 settlement: &settlement,
2978 pending_submits: &pending_submits,
2979 order_contexts: &order_contexts,
2980 emitter: &emitter,
2981 account_id: AccountId::from("POLY-001"),
2982 clock: nautilus_core::time::get_atomic_clock_realtime(),
2983 user_address: "0xtest",
2984 user_api_key: "test-key",
2985 };
2986
2987 reemit_terminal_cancel(venue_order_id, &state, &ctx);
2988
2989 match receiver.try_recv().expect("expected expired event") {
2990 ExecutionEvent::Order(OrderEventAny::Expired(event)) => {
2991 assert_eq!(event.client_order_id, ClientOrderId::from("O-GTD-EXPIRE"));
2992 }
2993 other => panic!("expected OrderExpired, was {other:?}"),
2994 }
2995 }
2996
2997 #[rstest]
3000 #[case(
3001 PolymarketOrderSide::Buy,
3002 PolymarketOrderType::FOK,
3003 dec!(1.01),
3004 dec!(0.01),
3005 dec!(101)
3006 )]
3007 #[case(
3008 PolymarketOrderSide::Buy,
3009 PolymarketOrderType::FOK,
3010 dec!(12),
3011 dec!(0.6),
3012 dec!(20)
3013 )]
3014 #[case(
3015 PolymarketOrderSide::Buy,
3016 PolymarketOrderType::FAK,
3017 dec!(1),
3018 dec!(0.01),
3019 dec!(100)
3020 )]
3021 #[case(
3022 PolymarketOrderSide::Buy,
3023 PolymarketOrderType::GTC,
3024 dec!(20),
3025 dec!(0.18),
3026 dec!(20)
3027 )]
3028 #[case(
3029 PolymarketOrderSide::Buy,
3030 PolymarketOrderType::GTD,
3031 dec!(20),
3032 dec!(0.18),
3033 dec!(20)
3034 )]
3035 #[case(
3036 PolymarketOrderSide::Sell,
3037 PolymarketOrderType::FOK,
3038 dec!(20),
3039 dec!(0.6),
3040 dec!(20)
3041 )]
3042 fn test_original_size_to_shares(
3043 #[case] side: PolymarketOrderSide,
3044 #[case] order_type: PolymarketOrderType,
3045 #[case] original_size: Decimal,
3046 #[case] price: Decimal,
3047 #[case] expected: Decimal,
3048 ) {
3049 let shares = original_size_to_shares(original_size, price, side, order_type).unwrap();
3050
3051 assert_eq!(shares, expected);
3052 }
3053
3054 #[rstest]
3056 #[case("1", "0.03", "33.333333", "0.03")]
3057 fn test_build_ws_order_status_report_fok_buy_quantity(
3058 #[case] original_size: &str,
3059 #[case] price: &str,
3060 #[case] expected_quantity: &str,
3061 #[case] expected_price: &str,
3062 ) {
3063 let mut order: PolymarketUserOrder = load("ws_user_order_fok_buy_pusd_size.json");
3064 order.original_size = original_size.to_string();
3065 order.price = price.to_string();
3066 let instrument = test_instrument();
3067
3068 let report = build_ws_order_status_report(
3069 &order,
3070 order.status.as_ref().unwrap(),
3071 order.order_type.unwrap(),
3072 &instrument,
3073 AccountId::from("POLY-001"),
3074 UnixNanos::from(1_000_000_000u64),
3075 UnixNanos::from(2_000_000_000u64),
3076 )
3077 .unwrap();
3078
3079 assert_eq!(
3080 report.quantity.as_decimal(),
3081 Decimal::from_str_exact(expected_quantity).unwrap()
3082 );
3083 assert_eq!(
3084 report.price.map(|price| price.as_decimal()),
3085 Some(Decimal::from_str_exact(expected_price).unwrap())
3086 );
3087 }
3088
3089 #[rstest]
3090 fn test_dispatch_fok_buy_registers_share_quantity_for_in_flight_submit() {
3091 let order: PolymarketUserOrder = load("ws_user_order_fok_buy_pusd_size.json");
3092 let instrument = test_instrument();
3093
3094 let token_instruments = AtomicMap::new();
3095 token_instruments.insert(order.asset_id, instrument.clone());
3096
3097 let fill_tracker = OrderFillTrackerMap::new();
3099 let pending_submits = PendingSubmitTracker::default();
3100 let order_contexts = OrderContextRegistry::default();
3101 let emitter = test_emitter();
3102
3103 let venue_order_id = VenueOrderId::from(order.id.as_str());
3104 let client_order_id = ClientOrderId::from("O-FOK-IN-FLIGHT");
3105 pending_submits.insert(venue_order_id, client_order_id);
3106 register_context(
3107 &order_contexts,
3108 venue_order_id,
3109 instrument.id(),
3110 client_order_id.as_str(),
3111 );
3112
3113 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
3114 settlement.mark_live();
3115 settlement.note_order_submitted(venue_order_id);
3116
3117 let ctx = WsDispatchContext {
3118 signer_type: PolymarketSignerType::Owner,
3119 token_instruments: &token_instruments,
3120 fill_tracker: &fill_tracker,
3121 settlement: &settlement,
3122 pending_submits: &pending_submits,
3123 order_contexts: &order_contexts,
3124 emitter: &emitter,
3125 account_id: AccountId::from("POLY-001"),
3126 clock: nautilus_core::time::get_atomic_clock_realtime(),
3127 user_address: "0xtest",
3128 user_api_key: "test-key",
3129 };
3130 let mut state = WsDispatchState::default();
3131
3132 dispatch_user_message(&UserWsMessage::Order(order), &ctx, &mut state);
3133
3134 assert_eq!(
3136 fill_tracker
3137 .submitted_qty(&venue_order_id)
3138 .map(|qty| qty.as_decimal()),
3139 Some(dec!(101)),
3140 );
3141 }
3142
3143 #[rstest]
3144 fn test_dispatch_fok_buy_report_quantity_is_shares_without_identity() {
3145 let order: PolymarketUserOrder = load("ws_user_order_fok_buy_pusd_size.json");
3146 let instrument = test_instrument();
3147
3148 let token_instruments = AtomicMap::new();
3149 token_instruments.insert(order.asset_id, instrument.clone());
3150
3151 let fill_tracker = OrderFillTrackerMap::new();
3152 let venue_order_id = VenueOrderId::from(order.id.as_str());
3153 fill_tracker.register(
3154 venue_order_id,
3155 Quantity::from("101"),
3156 OrderSide::Buy,
3157 instrument.id(),
3158 instrument.size_precision(),
3159 instrument.price_precision(),
3160 );
3161
3162 let pending_submits = PendingSubmitTracker::default();
3163 let order_contexts = OrderContextRegistry::default();
3165 let mut emitter = test_emitter();
3166 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
3167 emitter.set_sender(sender);
3168
3169 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
3170 settlement.mark_live();
3171 settlement.note_order_submitted(venue_order_id);
3172
3173 let ctx = WsDispatchContext {
3174 signer_type: PolymarketSignerType::Owner,
3175 token_instruments: &token_instruments,
3176 fill_tracker: &fill_tracker,
3177 settlement: &settlement,
3178 pending_submits: &pending_submits,
3179 order_contexts: &order_contexts,
3180 emitter: &emitter,
3181 account_id: AccountId::from("POLY-001"),
3182 clock: nautilus_core::time::get_atomic_clock_realtime(),
3183 user_address: "0xtest",
3184 user_api_key: "test-key",
3185 };
3186 let mut state = WsDispatchState::default();
3187
3188 dispatch_user_message(&UserWsMessage::Order(order), &ctx, &mut state);
3189
3190 let event = receiver.try_recv().expect("expected order report");
3191 let ExecutionEvent::Report(ExecutionReport::Order(report)) = event else {
3192 panic!("expected an order report, was {event:?}");
3193 };
3194
3195 assert_eq!(report.venue_order_id, venue_order_id);
3196 assert_eq!(report.order_side, Some(OrderSide::Buy));
3197 assert_eq!(report.time_in_force, TimeInForce::Fok);
3198 assert_eq!(report.order_status, OrderStatus::Canceled);
3199 assert_eq!(report.quantity.as_decimal(), dec!(101));
3200 assert_eq!(report.filled_qty.as_decimal(), dec!(0));
3201 assert_eq!(
3202 report.price.map(|price| price.as_decimal()),
3203 Some(dec!(0.01))
3204 );
3205 }
3206
3207 #[rstest]
3208 fn test_admit_stream_taker_trade_builds_the_leg() {
3209 let trade: PolymarketUserTrade = load("ws_user_trade.json");
3210 let instrument = instrument_for_trade(&trade);
3211 let instrument_id = instrument.id();
3212 let token_instruments = AtomicMap::new();
3213 token_instruments.insert(trade.asset_id, instrument);
3214 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
3215
3216 let ctx = WsDispatchContext {
3217 signer_type: PolymarketSignerType::Owner,
3218 token_instruments: &token_instruments,
3219 fill_tracker: &OrderFillTrackerMap::new(),
3220 settlement: &settlement,
3221 pending_submits: &PendingSubmitTracker::default(),
3222 order_contexts: &OrderContextRegistry::default(),
3223 emitter: &test_emitter(),
3224 account_id: AccountId::from("POLY-001"),
3225 clock: nautilus_core::time::get_atomic_clock_realtime(),
3226 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
3227 user_api_key: "00000000-0000-0000-0000-000000000001",
3228 };
3229
3230 let admitted =
3231 admit_trade_evidence(TradeEvidence::Stream(&trade), &ctx.admission_context())
3232 .expect("owned taker trade admits");
3233
3234 assert_eq!(admitted.venue_trade_id, trade.id);
3235 assert_eq!(admitted.status, trade.status);
3236 assert!(admitted.has_economics());
3237 assert_eq!(admitted.legs.len(), 1);
3238 let leg = &admitted.legs[0];
3239 assert_eq!(
3240 leg.venue_order_id,
3241 VenueOrderId::from(trade.taker_order_id.as_str())
3242 );
3243 assert_eq!(leg.trade_id.as_str(), trade.id);
3244 assert_eq!(leg.instrument_id, instrument_id);
3245 assert_eq!(leg.order_side, OrderSide::Buy);
3246 assert_eq!(leg.liquidity_side, LiquiditySide::Taker);
3247 assert_eq!(leg.last_qty.as_decimal(), dec!(25));
3248 assert_eq!(leg.last_px.as_decimal(), dec!(0.5));
3249 assert_eq!(leg.ts_event, UnixNanos::from(1_704_067_200_000_000_000u64));
3251 }
3252
3253 fn admission_context_for(
3254 token_instruments: &AtomicMap<Ustr, InstrumentAny>,
3255 ) -> AdmissionContext<'_> {
3256 AdmissionContext {
3257 signer_type: PolymarketSignerType::Owner,
3258 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
3259 api_key: "00000000-0000-0000-0000-000000000001",
3260 pusd: get_pusd_currency(),
3261 instruments: token_instruments,
3262 fee_bases: None,
3263 }
3264 }
3265
3266 #[rstest]
3267 fn test_admit_stream_fill_without_venue_match_time_is_untimestamped() {
3268 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
3269 trade.match_time = String::new();
3270 trade.timestamp = "not-a-timestamp".to_string();
3271 let token_instruments = AtomicMap::new();
3272 token_instruments.insert(trade.asset_id, instrument_for_trade(&trade));
3273
3274 let result = admit_trade_evidence(
3275 TradeEvidence::Stream(&trade),
3276 &admission_context_for(&token_instruments),
3277 );
3278
3279 let Err(AdmissionError::Untimestamped(e)) = result else {
3280 panic!("expected untimestamped evidence, was {result:?}");
3281 };
3282
3283 assert_eq!(
3284 e.to_string(),
3285 format!(
3286 "trade {} has no valid venue match timestamp (match_time=)",
3287 trade.id
3288 )
3289 );
3290 }
3291
3292 #[rstest]
3293 fn test_admit_stream_failed_trade_without_match_time_carries_no_economics() {
3294 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
3295 trade.status = PolymarketTradeStatus::Failed;
3296 trade.match_time = String::new();
3297 trade.timestamp = "not-a-timestamp".to_string();
3298 let instrument = instrument_for_trade(&trade);
3299 let instrument_id = instrument.id();
3300 let token_instruments = AtomicMap::new();
3301 token_instruments.insert(trade.asset_id, instrument);
3302
3303 let admitted = admit_trade_evidence(
3304 TradeEvidence::Stream(&trade),
3305 &admission_context_for(&token_instruments),
3306 )
3307 .expect("failed evidence admits owned-leg identity");
3308
3309 assert!(!admitted.has_economics());
3310 assert_eq!(admitted.legs.len(), 1);
3311 let leg = &admitted.legs[0];
3312 assert_eq!(
3313 leg.venue_order_id,
3314 VenueOrderId::from(trade.taker_order_id.as_str())
3315 );
3316 assert_eq!(leg.instrument_id, instrument_id);
3317 assert_eq!(leg.last_qty.as_decimal(), dec!(0));
3318 assert_eq!(leg.last_px.as_decimal(), dec!(0));
3319 assert!(leg.commission.is_zero());
3320 assert_eq!(leg.ts_event, UnixNanos::default());
3321 }
3322
3323 #[rstest]
3324 fn test_admit_price_keeps_instrument_precision_for_stream_and_wire_precision_for_rest() {
3325 let trade: PolymarketUserTrade = load("ws_user_trade.json");
3326 let instrument = instrument_for_trade(&trade);
3327 let price_precision = instrument.price_precision();
3328 let token_instruments = AtomicMap::new();
3329 token_instruments.insert(trade.asset_id, instrument);
3330 let mut rest: PolymarketTradeReport =
3331 serde_json::from_str(include_str!("../../test_data/http_trade_report.json"))
3332 .expect("REST trade fixture");
3333 rest.id = trade.id.clone();
3334 rest.taker_order_id = trade.taker_order_id.clone();
3335 let ctx = admission_context_for(&token_instruments);
3336
3337 let stream = admit_trade_evidence(TradeEvidence::Stream(&trade), &ctx)
3338 .expect("stream evidence admits");
3339 let rest =
3340 admit_trade_evidence(TradeEvidence::Rest(&rest), &ctx).expect("REST evidence admits");
3341
3342 assert_eq!(price_precision, 4);
3343 assert_eq!(stream.legs[0].last_px.as_decimal(), dec!(0.5));
3344 assert_eq!(stream.legs[0].last_px.precision, price_precision);
3345 assert_eq!(rest.legs[0].last_px, stream.legs[0].last_px);
3346 assert_eq!(rest.legs[0].last_px.precision, 1);
3347 }
3348
3349 #[rstest]
3350 #[case::settlement_rounding("0.4200001023529231", "1.758621", Some(dec!(0.42)))]
3351 #[case::beyond_settlement_rounding("0.42001", "5", None)]
3352 fn test_admit_maker_price_snaps_settlement_rounding_on_both_paths(
3353 #[case] wire_price: &str,
3354 #[case] matched_amount: &str,
3355 #[case] snapped: Option<Decimal>,
3356 ) {
3357 let wire_price = Decimal::from_str_exact(wire_price).unwrap();
3358 let matched_amount = Decimal::from_str_exact(matched_amount).unwrap();
3359 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
3360 trade.trader_side = PolymarketLiquiditySide::Maker;
3361 trade.maker_orders[0].price = wire_price;
3362 trade.maker_orders[0].matched_amount = matched_amount;
3363 let mut rest: PolymarketTradeReport =
3364 serde_json::from_str(include_str!("../../test_data/http_trade_report.json"))
3365 .expect("REST trade fixture");
3366 rest.trader_side = PolymarketLiquiditySide::Maker;
3367 rest.maker_orders[0].price = wire_price;
3368 rest.maker_orders[0].matched_amount = matched_amount;
3369 let token_instruments = AtomicMap::new();
3370 token_instruments.insert(trade.asset_id, instrument_for_trade(&trade));
3371 let maker_address = trade.maker_orders[0].maker_address.clone();
3372 let ctx = AdmissionContext {
3373 signer_type: PolymarketSignerType::Owner,
3374 user_address: &maker_address,
3375 api_key: "ffffffff-ffff-ffff-ffff-ffffffffffff",
3376 pusd: get_pusd_currency(),
3377 instruments: &token_instruments,
3378 fee_bases: None,
3379 };
3380
3381 let stream = admit_trade_evidence(TradeEvidence::Stream(&trade), &ctx);
3382 let rest =
3383 admit_trade_evidence(TradeEvidence::Rest(&rest), &ctx).expect("REST evidence admits");
3384
3385 if let Some(snapped) = snapped {
3386 let stream = stream.expect("stream evidence admits");
3387 assert_eq!(stream.legs[0].last_px.as_decimal(), snapped);
3388 assert_eq!(stream.legs[0].last_px.precision, 4);
3389 assert_eq!(rest.legs[0].last_px, stream.legs[0].last_px);
3390 } else {
3391 let Err(AdmissionError::Invalid(e)) = stream else {
3392 panic!("expected invalid stream evidence, was {stream:?}");
3393 };
3394 assert!(
3395 format!("{e:#}").contains("not exactly representable"),
3396 "unexpected error: {e:#}"
3397 );
3398 assert_eq!(rest.legs[0].last_px.as_decimal(), wire_price);
3399 }
3400 }
3401
3402 #[rstest]
3403 #[case::taker_order_id(false, "invalid venue order ID")]
3404 #[case::maker_trade_id(true, "invalid trade ID source")]
3405 fn test_admit_stream_rejects_invalid_identifiers_without_panicking(
3406 #[case] maker: bool,
3407 #[case] expected_error: &str,
3408 ) {
3409 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
3410 let token_instruments = AtomicMap::new();
3411 token_instruments.insert(trade.asset_id, instrument_for_trade(&trade));
3412 let maker_address = trade.maker_orders[0].maker_address.clone();
3413
3414 let user_address = if maker {
3415 trade.trader_side = PolymarketLiquiditySide::Maker;
3416 trade.id = "trade-\u{e9}".to_string();
3417 maker_address.as_str()
3418 } else {
3419 trade.taker_order_id = "order-\u{e9}".to_string();
3420 "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266"
3421 };
3422
3423 let ctx = AdmissionContext {
3424 signer_type: PolymarketSignerType::Owner,
3425 user_address,
3426 api_key: "ffffffff-ffff-ffff-ffff-ffffffffffff",
3427 pusd: get_pusd_currency(),
3428 instruments: &token_instruments,
3429 fee_bases: None,
3430 };
3431
3432 let result = admit_trade_evidence(TradeEvidence::Stream(&trade), &ctx);
3433
3434 let Err(AdmissionError::Invalid(e)) = result else {
3435 panic!("expected invalid evidence, was {result:?}");
3436 };
3437
3438 assert!(
3439 format!("{e:#}").contains(expected_error),
3440 "unexpected error: {e:#}"
3441 );
3442 }
3443
3444 #[rstest]
3445 fn test_trade_fill_info_flattens_raw_trade() {
3446 let trade: PolymarketUserTrade = load("ws_user_trade.json");
3447
3448 let info = trade_fill_info(&trade).expect("info should be present");
3449
3450 assert_eq!(info.len(), 21);
3452 assert_eq!(info[&Ustr::from("id")], Ustr::from("trade-0xabcdef1234"));
3453 assert_eq!(info[&Ustr::from("fee_rate_bps")], Ustr::from("0"));
3454 assert_eq!(
3455 info[&Ustr::from("transaction_hash")],
3456 Ustr::from("0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890ab")
3457 );
3458 assert_eq!(info[&Ustr::from("bucket_index")], Ustr::from("1"));
3460 assert_eq!(info[&Ustr::from("size")], Ustr::from("25.0"));
3461 assert_eq!(
3462 info[&Ustr::from("taker_order_id")],
3463 Ustr::from("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef12")
3464 );
3465 assert_eq!(info[&Ustr::from("type")], Ustr::from("TRADE"));
3467 let maker_orders = info[&Ustr::from("maker_orders")].as_str();
3469 assert!(maker_orders.starts_with('['));
3470 assert!(maker_orders.contains("order_id"));
3471
3472 let empty_hash_trade: PolymarketUserTrade = load("ws_user_trade_msg.json");
3473 let empty_hash_info =
3474 trade_fill_info(&empty_hash_trade).expect("empty hash info should be present");
3475 assert!(!empty_hash_info.contains_key(&Ustr::from("transaction_hash")));
3476 }
3477
3478 #[rstest]
3479 fn test_dispatch_order_message_buffers_when_not_accepted() {
3480 let order: PolymarketUserOrder = load("ws_user_order_placement.json");
3481 let instrument = test_instrument();
3482
3483 let token_instruments = AtomicMap::new();
3484 token_instruments.insert(order.asset_id, instrument);
3485
3486 let fill_tracker = OrderFillTrackerMap::new();
3487 let pending_submits = PendingSubmitTracker::default();
3488 let order_contexts = OrderContextRegistry::default();
3489 let emitter = test_emitter();
3490
3491 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
3492 settlement.mark_live();
3493
3494 let ctx = WsDispatchContext {
3495 signer_type: PolymarketSignerType::Owner,
3496 token_instruments: &token_instruments,
3497 fill_tracker: &fill_tracker,
3498 settlement: &settlement,
3499 pending_submits: &pending_submits,
3500 order_contexts: &order_contexts,
3501 emitter: &emitter,
3502 account_id: AccountId::from("POLY-001"),
3503 clock: nautilus_core::time::get_atomic_clock_realtime(),
3504 user_address: "0xtest",
3505 user_api_key: "test-key",
3506 };
3507 let mut state = WsDispatchState::default();
3508
3509 let result = dispatch_user_message(&UserWsMessage::Order(order.clone()), &ctx, &mut state);
3510 assert!(result.is_none());
3511
3512 let venue_order_id = VenueOrderId::from(order.id.as_str());
3514 assert!(fill_tracker.has_pending_report(&venue_order_id));
3515 }
3516
3517 #[rstest]
3518 fn test_dispatch_order_message_ignores_missing_lifecycle_fields() {
3519 let order: PolymarketUserOrder = load("ws_user_order_placement.json");
3520 let instrument = test_instrument();
3521 let token_instruments = AtomicMap::new();
3522 token_instruments.insert(order.asset_id, instrument);
3523 let fill_tracker = OrderFillTrackerMap::new();
3524 let pending_submits = PendingSubmitTracker::default();
3525 let order_contexts = OrderContextRegistry::default();
3526 let emitter = test_emitter();
3527 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
3528 settlement.mark_live();
3529
3530 let ctx = WsDispatchContext {
3531 signer_type: PolymarketSignerType::Owner,
3532 token_instruments: &token_instruments,
3533 fill_tracker: &fill_tracker,
3534 settlement: &settlement,
3535 pending_submits: &pending_submits,
3536 order_contexts: &order_contexts,
3537 emitter: &emitter,
3538 account_id: AccountId::from("POLY-001"),
3539 clock: nautilus_core::time::get_atomic_clock_realtime(),
3540 user_address: "0xtest",
3541 user_api_key: "test-key",
3542 };
3543 let venue_order_id = VenueOrderId::from(order.id.as_str());
3544
3545 let mut missing_status = order.clone();
3546 missing_status.status = None;
3547 dispatch_user_message(
3548 &UserWsMessage::Order(missing_status),
3549 &ctx,
3550 &mut WsDispatchState::default(),
3551 );
3552 assert!(!fill_tracker.has_pending_report(&venue_order_id));
3553
3554 let mut missing_order_type = order;
3555 missing_order_type.order_type = None;
3556 dispatch_user_message(
3557 &UserWsMessage::Order(missing_order_type),
3558 &ctx,
3559 &mut WsDispatchState::default(),
3560 );
3561 assert!(!fill_tracker.has_pending_report(&venue_order_id));
3562 }
3563
3564 #[rstest]
3565 fn test_dispatch_order_message_uses_pending_submit_client_order_id() {
3566 let order: PolymarketUserOrder = load("ws_user_order_placement.json");
3567 let instrument = test_instrument();
3568
3569 let token_instruments = AtomicMap::new();
3570 token_instruments.insert(order.asset_id, instrument);
3571
3572 let fill_tracker = OrderFillTrackerMap::new();
3573 let pending_submits = PendingSubmitTracker::default();
3574 let order_contexts = OrderContextRegistry::default();
3575 let mut emitter = test_emitter();
3576 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
3577 emitter.set_sender(sender);
3578
3579 let venue_order_id = VenueOrderId::from(order.id.as_str());
3580 let client_order_id = ClientOrderId::from("O-UNKNOWN-SUBMIT");
3581 pending_submits.insert(venue_order_id, client_order_id);
3582 register_context(
3583 &order_contexts,
3584 venue_order_id,
3585 test_instrument().id(),
3586 "O-UNKNOWN-SUBMIT",
3587 );
3588
3589 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
3590 settlement.mark_live();
3591 settlement.note_order_submitted(venue_order_id);
3592
3593 let ctx = WsDispatchContext {
3594 signer_type: PolymarketSignerType::Owner,
3595 token_instruments: &token_instruments,
3596 fill_tracker: &fill_tracker,
3597 settlement: &settlement,
3598 pending_submits: &pending_submits,
3599 order_contexts: &order_contexts,
3600 emitter: &emitter,
3601 account_id: AccountId::from("POLY-001"),
3602 clock: nautilus_core::time::get_atomic_clock_realtime(),
3603 user_address: "0xtest",
3604 user_api_key: "test-key",
3605 };
3606 let mut state = WsDispatchState::default();
3607
3608 let _ = dispatch_user_message(&UserWsMessage::Order(order), &ctx, &mut state);
3609
3610 let event = receiver.try_recv().expect("expected accepted event");
3612 match event {
3613 ExecutionEvent::Order(OrderEventAny::Accepted(accepted)) => {
3614 assert_eq!(accepted.client_order_id, client_order_id);
3615 }
3616 other => panic!("Expected accepted event, was {other:?}"),
3617 }
3618
3619 assert!(!fill_tracker.has_pending_report(&venue_order_id));
3620 }
3621
3622 #[rstest]
3623 #[case(PolymarketSignerType::Owner, 1)]
3624 #[case(PolymarketSignerType::Session, 0)]
3625 fn test_dispatch_maker_fill_owned_by_case_variant_address(
3626 #[case] signer_type: PolymarketSignerType,
3627 #[case] expected_fills: usize,
3628 ) {
3629 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
3630 trade.trader_side = PolymarketLiquiditySide::Maker;
3631 let configured_address = trade.maker_orders[0].maker_address.clone();
3632 let case_variant_address = configured_address
3633 .to_ascii_uppercase()
3634 .replacen("0X", "0x", 1);
3635 assert_ne!(case_variant_address, configured_address);
3636 trade.maker_orders[0].maker_address = case_variant_address;
3637 let foreign_api_key = "ffffffff-ffff-ffff-ffff-ffffffffffff";
3638 assert_ne!(trade.maker_orders[0].owner, foreign_api_key);
3639
3640 let venue_order_id = VenueOrderId::from(trade.maker_orders[0].order_id.as_str());
3641 let token_instruments = AtomicMap::new();
3642 token_instruments.insert(trade.maker_orders[0].asset_id, instrument_for_trade(&trade));
3643 let fill_tracker = OrderFillTrackerMap::new();
3644 let pending_submits = PendingSubmitTracker::default();
3645 let order_contexts = OrderContextRegistry::default();
3646 let emitter = test_emitter();
3647 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
3648 settlement.mark_live();
3649 settlement.note_order_submitted(venue_order_id);
3650
3651 let ctx = WsDispatchContext {
3652 signer_type,
3653 token_instruments: &token_instruments,
3654 fill_tracker: &fill_tracker,
3655 settlement: &settlement,
3656 pending_submits: &pending_submits,
3657 order_contexts: &order_contexts,
3658 emitter: &emitter,
3659 account_id: AccountId::from("POLY-001"),
3660 clock: nautilus_core::time::get_atomic_clock_realtime(),
3661 user_address: &configured_address,
3662 user_api_key: foreign_api_key,
3663 };
3664 let mut state = WsDispatchState::default();
3665
3666 let _ = dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
3667
3668 let fills = fill_tracker.pending_fills_for(&venue_order_id);
3669 assert_eq!(fills.len(), expected_fills);
3670
3671 for fill in fills {
3672 assert_eq!(fill.venue_order_id, venue_order_id);
3673 }
3674 }
3675
3676 #[rstest]
3677 fn test_dispatch_maker_fill_with_settlement_rounded_price_applies_without_quarantine() {
3678 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
3679 trade.trader_side = PolymarketLiquiditySide::Maker;
3680 trade.status = PolymarketTradeStatus::Matched;
3681 trade.maker_orders[0].price = dec!(0.4200001023529231);
3682 trade.maker_orders[0].matched_amount = dec!(1.758621);
3683 let configured_address = trade.maker_orders[0].maker_address.clone();
3684
3685 let venue_order_id = VenueOrderId::from(trade.maker_orders[0].order_id.as_str());
3686 let token_instruments = AtomicMap::new();
3687 token_instruments.insert(trade.maker_orders[0].asset_id, instrument_for_trade(&trade));
3688 let fill_tracker = OrderFillTrackerMap::new();
3689 let pending_submits = PendingSubmitTracker::default();
3690 let order_contexts = OrderContextRegistry::default();
3691 let emitter = test_emitter();
3692 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
3693 settlement.mark_live();
3694 settlement.note_order_submitted(venue_order_id);
3695
3696 let ctx = WsDispatchContext {
3697 signer_type: PolymarketSignerType::Owner,
3698 token_instruments: &token_instruments,
3699 fill_tracker: &fill_tracker,
3700 settlement: &settlement,
3701 pending_submits: &pending_submits,
3702 order_contexts: &order_contexts,
3703 emitter: &emitter,
3704 account_id: AccountId::from("POLY-001"),
3705 clock: nautilus_core::time::get_atomic_clock_realtime(),
3706 user_address: &configured_address,
3707 user_api_key: "ffffffff-ffff-ffff-ffff-ffffffffffff",
3708 };
3709 let mut state = WsDispatchState::default();
3710 let trade_id = trade.id.clone();
3711
3712 let _ = dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
3713
3714 let fills = fill_tracker.pending_fills_for(&venue_order_id);
3715 assert_eq!(fills.len(), 1);
3716 assert_eq!(fills[0].last_px, Price::from("0.4200"));
3717 assert_eq!(fills[0].last_qty, Quantity::from("1.758621"));
3718 assert_eq!(
3719 settlement_state(&settlement, &trade_id),
3720 Some(SettlementState::Provisional)
3721 );
3722 }
3723
3724 #[rstest]
3725 #[case(dec!(-1))]
3726 #[case(Decimal::MAX)]
3727 fn test_dispatch_maker_numeric_failure_quarantines_trade(#[case] invalid_amount: Decimal) {
3728 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
3729 trade.status = PolymarketTradeStatus::Confirmed;
3730 trade.trader_side = PolymarketLiquiditySide::Maker;
3731 let configured_address = trade.maker_orders[0].maker_address.clone();
3732 let foreign_api_key = "ffffffff-ffff-ffff-ffff-ffffffffffff";
3733 assert_ne!(trade.maker_orders[0].owner, foreign_api_key);
3734
3735 let venue_order_id = VenueOrderId::from(trade.maker_orders[0].order_id.as_str());
3736 let token_instruments = AtomicMap::new();
3737 token_instruments.insert(trade.maker_orders[0].asset_id, instrument_for_trade(&trade));
3738 let fill_tracker = OrderFillTrackerMap::new();
3739 let pending_submits = PendingSubmitTracker::default();
3740 let order_contexts = OrderContextRegistry::default();
3741 let emitter = test_emitter();
3742 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
3743 settlement.mark_live();
3744 settlement.note_order_submitted(venue_order_id);
3745
3746 let ctx = WsDispatchContext {
3747 signer_type: PolymarketSignerType::Owner,
3748 token_instruments: &token_instruments,
3749 fill_tracker: &fill_tracker,
3750 settlement: &settlement,
3751 pending_submits: &pending_submits,
3752 order_contexts: &order_contexts,
3753 emitter: &emitter,
3754 account_id: AccountId::from("POLY-001"),
3755 clock: nautilus_core::time::get_atomic_clock_realtime(),
3756 user_address: &configured_address,
3757 user_api_key: foreign_api_key,
3758 };
3759
3760 let mut state = WsDispatchState::default();
3761
3762 let mut second_leg = trade.maker_orders[0].clone();
3763 second_leg.order_id = "O-MAKER-SECOND".to_string();
3764 second_leg.matched_amount = dec!(7);
3765 let second_venue_order_id = VenueOrderId::from(second_leg.order_id.as_str());
3766 settlement.note_order_submitted(second_venue_order_id);
3767 trade.maker_orders.push(second_leg);
3768
3769 let mut invalid_trade = trade.clone();
3770 invalid_trade.maker_orders[1].matched_amount = invalid_amount;
3771 dispatch_user_message(&UserWsMessage::Trade(invalid_trade), &ctx, &mut state);
3772 assert_eq!(fill_tracker.pending_fills_for(&venue_order_id).len(), 0);
3773 assert!(
3774 fill_tracker
3775 .pending_fills_for(&second_venue_order_id)
3776 .is_empty()
3777 );
3778 assert_eq!(
3779 settlement_state(&settlement, &trade.id),
3780 Some(SettlementState::Quarantined)
3781 );
3782
3783 assert!(
3784 admit_trade_evidence(TradeEvidence::Stream(&trade), &ctx.admission_context()).is_ok()
3785 );
3786 dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
3787
3788 assert!(
3789 fill_tracker.pending_fills_for(&venue_order_id).is_empty(),
3790 "invalid stream evidence quarantines; a later valid copy stays REST-gated"
3791 );
3792 assert!(
3793 fill_tracker
3794 .pending_fills_for(&second_venue_order_id)
3795 .is_empty()
3796 );
3797 assert_eq!(
3798 settlement_state(&settlement, &trade.id),
3799 Some(SettlementState::Quarantined)
3800 );
3801 }
3802
3803 #[rstest]
3804 fn test_dispatch_trade_dedup() {
3805 let trade: PolymarketUserTrade = load("ws_user_trade.json");
3806 let instrument = instrument_for_trade(&trade);
3807
3808 let token_instruments = AtomicMap::new();
3809 token_instruments.insert(trade.asset_id, instrument);
3810
3811 let fill_tracker = OrderFillTrackerMap::new();
3812 let pending_submits = PendingSubmitTracker::default();
3813 let order_contexts = OrderContextRegistry::default();
3814 let emitter = test_emitter();
3815
3816 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
3817 settlement.note_order_submitted(VenueOrderId::from(trade.taker_order_id.as_str()));
3818
3819 let ctx = WsDispatchContext {
3820 signer_type: PolymarketSignerType::Owner,
3821 token_instruments: &token_instruments,
3822 fill_tracker: &fill_tracker,
3823 settlement: &settlement,
3824 pending_submits: &pending_submits,
3825 order_contexts: &order_contexts,
3826 emitter: &emitter,
3827 account_id: AccountId::from("POLY-001"),
3828 clock: nautilus_core::time::get_atomic_clock_realtime(),
3829 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
3830 user_api_key: "00000000-0000-0000-0000-000000000001",
3831 };
3832
3833 let mut state = WsDispatchState::default();
3834
3835 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
3836
3837 let _ = dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
3839 assert_eq!(fill_tracker.pending_fills_for(&venue_order_id).len(), 1);
3840
3841 let _ = dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
3843 assert_eq!(fill_tracker.pending_fills_for(&venue_order_id).len(), 1);
3844 }
3845
3846 #[rstest]
3847 fn test_dispatch_taker_commission_failure_quarantines_trade() {
3848 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
3849 trade.status = PolymarketTradeStatus::Confirmed;
3850 let mut valid_instrument = instrument_for_trade(&trade);
3851 set_taker_fee_rate(&mut valid_instrument, dec!(0.03));
3852 let mut invalid_instrument = valid_instrument.clone();
3853 set_taker_fee_rate(
3854 &mut invalid_instrument,
3855 Decimal::from_i128_with_scale(100_000_000_000_000_000_000_000_000i128, 0),
3856 );
3857
3858 let token_instruments = AtomicMap::new();
3859 token_instruments.insert(trade.asset_id, invalid_instrument);
3860 let fill_tracker = OrderFillTrackerMap::new();
3861 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
3862 fill_tracker.register(
3863 venue_order_id,
3864 Quantity::from("100"),
3865 OrderSide::Buy,
3866 valid_instrument.id(),
3867 valid_instrument.size_precision(),
3868 valid_instrument.price_precision(),
3869 );
3870 let pending_submits = PendingSubmitTracker::default();
3871 let order_contexts = OrderContextRegistry::default();
3872 register_context(
3873 &order_contexts,
3874 venue_order_id,
3875 valid_instrument.id(),
3876 "O-COMMISSION-REPLAY",
3877 );
3878 order_contexts.mark_accepted(venue_order_id);
3879 let mut emitter = test_emitter();
3880 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
3881 emitter.set_sender(sender);
3882 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
3883 settlement.mark_live();
3884 settlement.note_order_submitted(venue_order_id);
3885
3886 let ctx = WsDispatchContext {
3887 signer_type: PolymarketSignerType::Owner,
3888 token_instruments: &token_instruments,
3889 fill_tracker: &fill_tracker,
3890 settlement: &settlement,
3891 pending_submits: &pending_submits,
3892 order_contexts: &order_contexts,
3893 emitter: &emitter,
3894 account_id: AccountId::from("POLY-001"),
3895 clock: nautilus_core::time::get_atomic_clock_realtime(),
3896 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
3897 user_api_key: "00000000-0000-0000-0000-000000000001",
3898 };
3899
3900 let mut state = WsDispatchState::default();
3901
3902 let failed = dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
3903
3904 assert!(failed.is_none());
3905 assert_eq!(
3906 settlement_state(&settlement, &trade.id),
3907 Some(SettlementState::Quarantined)
3908 );
3909 assert_eq!(
3910 fill_tracker.get_cumulative_filled(&venue_order_id),
3911 Some(Quantity::zero(valid_instrument.size_precision()))
3912 );
3913 assert!(receiver.try_recv().is_err());
3914
3915 token_instruments.insert(trade.asset_id, valid_instrument.clone());
3917 assert!(
3918 admit_trade_evidence(TradeEvidence::Stream(&trade), &ctx.admission_context()).is_ok()
3919 );
3920 let replay = dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
3921
3922 assert!(replay.is_none());
3923 assert_eq!(
3924 settlement_state(&settlement, &trade.id),
3925 Some(SettlementState::Quarantined)
3926 );
3927 assert!(receiver.try_recv().is_err());
3928
3929 let mut rest_trade: PolymarketTradeReport = load("http_trade_report.json");
3930 rest_trade.size = dec!(17);
3931 rest_trade.price = dec!(0.4);
3932 rest_trade.maker_orders.truncate(1);
3933 rest_trade.maker_orders[0].matched_amount = dec!(17);
3934 rest_trade.maker_orders[0].price = dec!(0.4);
3935 rest_trade.status = PolymarketTradeStatus::Matched;
3936
3937 apply_rest_trade_evidence(&rest_trade, &ctx, &mut state);
3938
3939 assert_eq!(
3940 settlement_state(&settlement, &trade.id),
3941 Some(SettlementState::Quarantined)
3942 );
3943 assert!(receiver.try_recv().is_err());
3944
3945 rest_trade.status = PolymarketTradeStatus::Confirmed;
3946 apply_rest_trade_evidence(&rest_trade, &ctx, &mut state);
3947
3948 let filled = match receiver.try_recv().unwrap() {
3949 ExecutionEvent::Order(OrderEventAny::Filled(event)) => event,
3950 other => panic!("expected recovered fill, was {other:?}"),
3951 };
3952
3953 assert_eq!(filled.account_id, ctx.account_id);
3954 assert_eq!(
3955 filled.client_order_id,
3956 ClientOrderId::from("O-COMMISSION-REPLAY")
3957 );
3958 assert_eq!(filled.venue_order_id, venue_order_id);
3959 assert_eq!(filled.trade_id, TradeId::from(trade.id.as_str()));
3960 assert_eq!(filled.instrument_id, valid_instrument.id());
3961 assert_eq!(filled.order_side, OrderSide::Buy);
3962 assert_eq!(filled.liquidity_side, LiquiditySide::Taker);
3963 assert_eq!(filled.last_qty.as_decimal(), dec!(17));
3964 assert_eq!(filled.last_px.as_decimal(), dec!(0.4));
3965 assert_eq!(filled.commission, Some(Money::from("0.12240 pUSD")));
3966 assert_eq!(
3967 filled.ts_event,
3968 UnixNanos::from(1_704_067_200_000_000_000u64)
3969 );
3970 assert_eq!(
3971 fill_tracker.get_cumulative_filled(&venue_order_id),
3972 Some(Quantity::from("17"))
3973 );
3974 assert_eq!(
3975 settlement_state(&settlement, &trade.id),
3976 Some(SettlementState::RestConfirmed)
3977 );
3978 assert!(receiver.try_recv().is_err());
3979
3980 apply_rest_trade_evidence(&rest_trade, &ctx, &mut state);
3981 settlement.observe_fill_applied(&filled);
3982 apply_rest_trade_evidence(&rest_trade, &ctx, &mut state);
3983
3984 assert!(receiver.try_recv().is_err());
3985 assert_eq!(
3986 fill_tracker.get_cumulative_filled(&venue_order_id),
3987 Some(Quantity::from("17"))
3988 );
3989 assert!(trade_hard_fault(&settlement, &trade.id).is_none());
3990 }
3991
3992 #[rstest]
3993 fn test_dispatch_untimestamped_trade_quarantines_and_requests_resolution() {
3994 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
3995 trade.status = PolymarketTradeStatus::Matched;
3996 trade.match_time = String::new();
3997 trade.timestamp = "not-a-timestamp".to_string();
3998 let token_instruments = AtomicMap::new();
3999 token_instruments.insert(trade.asset_id, instrument_for_trade(&trade));
4000 let fill_tracker = OrderFillTrackerMap::new();
4001 let pending_submits = PendingSubmitTracker::default();
4002 let order_contexts = OrderContextRegistry::default();
4003 let mut emitter = test_emitter();
4004 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
4005 emitter.set_sender(sender);
4006 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
4007 settlement.mark_live();
4008 settlement.note_order_submitted(VenueOrderId::from(trade.taker_order_id.as_str()));
4009
4010 let ctx = WsDispatchContext {
4011 signer_type: PolymarketSignerType::Owner,
4012 token_instruments: &token_instruments,
4013 fill_tracker: &fill_tracker,
4014 settlement: &settlement,
4015 pending_submits: &pending_submits,
4016 order_contexts: &order_contexts,
4017 emitter: &emitter,
4018 account_id: AccountId::from("POLY-001"),
4019 clock: nautilus_core::time::get_atomic_clock_realtime(),
4020 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
4021 user_api_key: "00000000-0000-0000-0000-000000000001",
4022 };
4023
4024 let mut state = WsDispatchState::default();
4025
4026 let refresh = dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
4027
4028 assert!(refresh.is_none());
4029 assert_eq!(
4030 settlement_state(&settlement, &trade.id),
4031 Some(SettlementState::Quarantined)
4032 );
4033 assert_eq!(settlement.pending_resolutions(), vec![trade.id]);
4034 assert!(receiver.try_recv().is_err());
4035 }
4036
4037 #[rstest]
4038 fn test_dispatch_trade_replays_after_instrument_becomes_available() {
4039 let trade: PolymarketUserTrade = load("ws_user_trade.json");
4040 let instrument = instrument_for_trade(&trade);
4041 let token_instruments = AtomicMap::new();
4042 let fill_tracker = OrderFillTrackerMap::new();
4043 let pending_submits = PendingSubmitTracker::default();
4044 let order_contexts = OrderContextRegistry::default();
4045 let emitter = test_emitter();
4046 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
4047 settlement.note_order_submitted(VenueOrderId::from(trade.taker_order_id.as_str()));
4048
4049 let ctx = WsDispatchContext {
4050 signer_type: PolymarketSignerType::Owner,
4051 token_instruments: &token_instruments,
4052 fill_tracker: &fill_tracker,
4053 settlement: &settlement,
4054 pending_submits: &pending_submits,
4055 order_contexts: &order_contexts,
4056 emitter: &emitter,
4057 account_id: AccountId::from("POLY-001"),
4058 clock: nautilus_core::time::get_atomic_clock_realtime(),
4059 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
4060 user_api_key: "00000000-0000-0000-0000-000000000001",
4061 };
4062
4063 let mut state = WsDispatchState::default();
4064 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
4065
4066 let first_result =
4067 dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
4068 token_instruments.insert(trade.asset_id, instrument);
4069 let replay_result = dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
4070
4071 assert!(first_result.is_none());
4072 assert!(replay_result.is_some());
4073 assert_eq!(fill_tracker.pending_fills_for(&venue_order_id).len(), 1);
4074 }
4075
4076 #[rstest]
4077 #[case(crate::common::enums::PolymarketTradeStatus::Mined)]
4078 #[case(crate::common::enums::PolymarketTradeStatus::Retrying)]
4079 fn test_dispatch_trade_applies_mined_and_retrying_provisionally(
4080 #[case] status: crate::common::enums::PolymarketTradeStatus,
4081 ) {
4082 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
4083 trade.status = status;
4084 let instrument = instrument_for_trade(&trade);
4085 let token_instruments = AtomicMap::new();
4086 token_instruments.insert(trade.asset_id, instrument);
4087 let fill_tracker = OrderFillTrackerMap::new();
4088 let pending_submits = PendingSubmitTracker::default();
4089 let order_contexts = OrderContextRegistry::default();
4090 let emitter = test_emitter();
4091 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
4092 settlement.note_order_submitted(VenueOrderId::from(trade.taker_order_id.as_str()));
4093
4094 let ctx = WsDispatchContext {
4095 signer_type: PolymarketSignerType::Owner,
4096 token_instruments: &token_instruments,
4097 fill_tracker: &fill_tracker,
4098 settlement: &settlement,
4099 pending_submits: &pending_submits,
4100 order_contexts: &order_contexts,
4101 emitter: &emitter,
4102 account_id: AccountId::from("POLY-001"),
4103 clock: nautilus_core::time::get_atomic_clock_realtime(),
4104 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
4105 user_api_key: "00000000-0000-0000-0000-000000000001",
4106 };
4107
4108 let mut state = WsDispatchState::default();
4109 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
4110 let trade_id = trade.id.clone();
4111
4112 let result = dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
4113
4114 assert!(result.is_none());
4115 assert_eq!(fill_tracker.pending_fills_for(&venue_order_id).len(), 1);
4116 assert_eq!(
4117 settlement_state(&settlement, &trade_id),
4118 Some(SettlementState::Provisional)
4119 );
4120 }
4121
4122 #[rstest]
4123 #[case::taker(false)]
4124 #[case::maker(true)]
4125 fn test_dispatch_matched_fill_confirmed_by_rest_at_wire_precision_does_not_conflict(
4126 #[case] maker: bool,
4127 ) {
4128 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
4129 trade.status = PolymarketTradeStatus::Matched;
4130
4131 if maker {
4132 trade.trader_side = PolymarketLiquiditySide::Maker;
4133 trade.side = PolymarketOrderSide::Sell;
4134 trade.maker_orders[0].matched_amount = dec!(20);
4135 }
4136
4137 let (order_id, user_address, api_key) = if maker {
4138 let leg = &trade.maker_orders[0];
4139 (
4140 leg.order_id.as_str(),
4141 leg.maker_address.as_str(),
4142 leg.owner.as_str(),
4143 )
4144 } else {
4145 (
4146 trade.taker_order_id.as_str(),
4147 trade.maker_address.as_str(),
4148 trade.owner.as_str(),
4149 )
4150 };
4151
4152 let instrument = instrument_for_trade(&trade);
4153 let token_instruments = AtomicMap::new();
4154 token_instruments.insert(trade.asset_id, instrument.clone());
4155 let fill_tracker = OrderFillTrackerMap::new();
4156 let venue_order_id = VenueOrderId::from(order_id);
4157 fill_tracker.register(
4158 venue_order_id,
4159 Quantity::from("100"),
4160 OrderSide::Buy,
4161 instrument.id(),
4162 instrument.size_precision(),
4163 instrument.price_precision(),
4164 );
4165 let pending_submits = PendingSubmitTracker::default();
4166 let order_contexts = OrderContextRegistry::default();
4167 register_context(
4168 &order_contexts,
4169 venue_order_id,
4170 instrument.id(),
4171 "O-MATCHED-CONFIRMED",
4172 );
4173 order_contexts.mark_accepted(venue_order_id);
4174 let mut emitter = test_emitter();
4175 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
4176 emitter.set_sender(sender);
4177 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
4178 settlement.mark_live();
4179 settlement.note_order_submitted(venue_order_id);
4180
4181 let ctx = WsDispatchContext {
4182 signer_type: PolymarketSignerType::Owner,
4183 token_instruments: &token_instruments,
4184 fill_tracker: &fill_tracker,
4185 settlement: &settlement,
4186 pending_submits: &pending_submits,
4187 order_contexts: &order_contexts,
4188 emitter: &emitter,
4189 account_id: AccountId::from("POLY-001"),
4190 clock: nautilus_core::time::get_atomic_clock_realtime(),
4191 user_address,
4192 user_api_key: api_key,
4193 };
4194
4195 let mut state = WsDispatchState::default();
4196
4197 let _ = dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
4198
4199 let filled = match receiver.try_recv().unwrap() {
4200 ExecutionEvent::Order(OrderEventAny::Filled(event)) => event,
4201 other => panic!("expected matched fill, was {other:?}"),
4202 };
4203
4204 settlement.observe_fill_applied(&filled);
4205
4206 let mut rest_confirmed: PolymarketTradeReport =
4207 serde_json::from_str(include_str!("../../test_data/http_trade_report.json"))
4208 .expect("REST trade fixture");
4209 rest_confirmed.id = trade.id.clone();
4210 rest_confirmed.taker_order_id = trade.taker_order_id.clone();
4211 rest_confirmed.trader_side = trade.trader_side;
4212 rest_confirmed.side = trade.side;
4213
4214 if maker {
4215 rest_confirmed.maker_orders[0].side = Some(PolymarketOrderSide::Buy);
4216 }
4217
4218 let rest_evidence = admit_trade_evidence(
4219 TradeEvidence::Rest(&rest_confirmed),
4220 &ctx.admission_context(),
4221 )
4222 .expect("REST CONFIRMED evidence admits");
4223 let rest_actions = settlement.admit_rest_result(&rest_evidence);
4224 execute_settlement_actions(
4225 rest_actions,
4226 rest_trade_info(&rest_confirmed).as_ref(),
4227 &ctx,
4228 &mut state,
4229 );
4230
4231 assert_eq!(rest_evidence.legs[0].last_px, filled.last_px);
4232 assert_eq!(rest_evidence.legs[0].venue_order_id, filled.venue_order_id);
4233 assert_eq!(rest_evidence.legs[0].trade_id, filled.trade_id);
4234 assert_eq!(rest_evidence.legs[0].instrument_id, filled.instrument_id);
4235 assert_eq!(rest_evidence.legs[0].order_side, OrderSide::Buy);
4236 assert_eq!(filled.order_side, OrderSide::Buy);
4237
4238 let liquidity = if maker {
4239 LiquiditySide::Maker
4240 } else {
4241 LiquiditySide::Taker
4242 };
4243
4244 assert_eq!(rest_evidence.legs[0].liquidity_side, liquidity);
4245 assert_eq!(filled.liquidity_side, liquidity);
4246 assert_eq!(rest_evidence.legs[0].last_qty, filled.last_qty);
4247 assert_eq!(rest_evidence.legs[0].commission, filled.commission.unwrap());
4248 assert_eq!(rest_evidence.legs[0].ts_event, filled.ts_event);
4249 assert_ne!(
4250 rest_evidence.legs[0].last_px.precision,
4251 filled.last_px.precision
4252 );
4253 assert!(trade_hard_fault(&settlement, &trade.id).is_none());
4254 assert_eq!(
4255 settlement_state(&settlement, &trade.id),
4256 Some(SettlementState::RestConfirmed)
4257 );
4258 assert!(receiver.try_recv().is_err());
4259 assert_eq!(
4260 fill_tracker.get_cumulative_filled(&venue_order_id),
4261 Some(filled.last_qty)
4262 );
4263 }
4264
4265 #[rstest]
4266 #[case::open_order(PolymarketOrderStatus::Live, None, true, false)]
4267 #[case::canceled_order(PolymarketOrderStatus::Canceled, None, true, false)]
4268 #[case::confirmed_fill(
4269 PolymarketOrderStatus::Matched,
4270 Some(PolymarketTradeStatus::Confirmed),
4271 true,
4272 true
4273 )]
4274 #[case::pending_trade(
4275 PolymarketOrderStatus::Matched,
4276 Some(PolymarketTradeStatus::Matched),
4277 false,
4278 false
4279 )]
4280 #[case::matched_before_trades_listed(PolymarketOrderStatus::Matched, None, false, false)]
4281 fn test_apply_uncertain_order_evidence(
4282 #[case] order_status: PolymarketOrderStatus,
4283 #[case] trade_status: Option<PolymarketTradeStatus>,
4284 #[case] expected_applied: bool,
4285 #[case] expected_fill: bool,
4286 #[values(false, true)] locally_closed: bool,
4287 #[values(false, true)] replacement_promoted: bool,
4288 ) {
4289 let mut order: PolymarketOpenOrder =
4290 serde_json::from_str(include_str!("../../test_data/http_open_order.json"))
4291 .expect("REST open order fixture");
4292 order.status = order_status;
4293 order.original_size = dec!(25);
4294
4295 order.size_matched = if order_status == PolymarketOrderStatus::Matched {
4296 dec!(25)
4297 } else {
4298 Decimal::ZERO
4299 };
4300
4301 let mut trade: PolymarketTradeReport =
4302 serde_json::from_str(include_str!("../../test_data/http_trade_report.json"))
4303 .expect("REST trade fixture");
4304 trade.status = trade_status.unwrap_or(PolymarketTradeStatus::Confirmed);
4305 let trades = trade_status
4306 .map(|_| vec![trade.clone()])
4307 .unwrap_or_default();
4308 let ws_trade: PolymarketUserTrade = load("ws_user_trade.json");
4309 let instrument = instrument_for_trade(&ws_trade);
4310 let token_instruments = AtomicMap::new();
4311 token_instruments.insert(order.asset_id, instrument.clone());
4312 let venue_order_id = VenueOrderId::from(order.id.as_str());
4313 let client_order_id = ClientOrderId::from("O-UNCERTAIN");
4314 let fill_tracker = OrderFillTrackerMap::new();
4315 let pending_submits = PendingSubmitTracker::default();
4316 pending_submits.insert(venue_order_id, client_order_id);
4317 let order_contexts = OrderContextRegistry::default();
4318 register_context(
4319 &order_contexts,
4320 venue_order_id,
4321 instrument.id(),
4322 client_order_id.as_str(),
4323 );
4324 order_contexts.set_closed(client_order_id, locally_closed);
4325 let mut emitter = test_emitter();
4326 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
4327 emitter.set_sender(sender);
4328 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
4329 settlement.begin_session();
4330
4331 let ctx = WsDispatchContext {
4332 signer_type: PolymarketSignerType::Owner,
4333 token_instruments: &token_instruments,
4334 fill_tracker: &fill_tracker,
4335 settlement: &settlement,
4336 pending_submits: &pending_submits,
4337 order_contexts: &order_contexts,
4338 emitter: &emitter,
4339 account_id: AccountId::from("POLY-001"),
4340 clock: nautilus_core::time::get_atomic_clock_realtime(),
4341 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
4342 user_api_key: "00000000-0000-0000-0000-000000000001",
4343 };
4344
4345 let mut state = WsDispatchState::default();
4346
4347 if replacement_promoted {
4348 let replacement_id = VenueOrderId::from("V-REPLACEMENT");
4349 assert!(state.begin_modify(client_order_id, venue_order_id, instrument.id()));
4350 assert!(state.set_modify_replacement(
4351 client_order_id,
4352 replacement_id,
4353 Quantity::from("25"),
4354 Quantity::from("25"),
4355 Quantity::from("0"),
4356 Price::from("0.6"),
4357 ));
4358 assert!(state.claim_modify_replacement(replacement_id).is_some());
4359 order_contexts.mark_accepted(venue_order_id);
4360 }
4361
4362 let applied =
4363 apply_uncertain_order_evidence(venue_order_id, &order, &trades, &ctx, &mut state);
4364
4365 let mut events = Vec::new();
4366
4367 while let Ok(event) = receiver.try_recv() {
4368 events.push(event);
4369 }
4370
4371 let accepted = events.iter().filter(|event| {
4372 matches!(event, ExecutionEvent::Order(OrderEventAny::Accepted(accepted))
4373 if accepted.client_order_id == client_order_id
4374 && accepted.venue_order_id == venue_order_id)
4375 });
4376
4377 let fills: Vec<&OrderFilled> = events
4378 .iter()
4379 .filter_map(|event| match event {
4380 ExecutionEvent::Order(OrderEventAny::Filled(filled)) => Some(filled),
4381 _ => None,
4382 })
4383 .collect();
4384
4385 assert_eq!(applied, expected_applied);
4386 assert_eq!(
4387 accepted.count(),
4388 usize::from(expected_applied && !locally_closed && !replacement_promoted)
4389 );
4390 assert_eq!(fill_tracker.contains(&venue_order_id), expected_applied);
4391
4392 if expected_fill {
4393 assert_eq!(fills.len(), 1);
4394 assert_eq!(fills[0].client_order_id, client_order_id);
4395 assert_eq!(fills[0].venue_order_id, venue_order_id);
4396 assert_eq!(fills[0].trade_id, TradeId::from(trade.id.as_str()));
4397 assert_eq!(fills[0].last_qty.as_decimal(), dec!(25));
4398 assert_eq!(fills[0].last_px.as_decimal(), dec!(0.5));
4399 assert_eq!(
4400 settlement_state(&settlement, &trade.id),
4401 Some(SettlementState::RestConfirmed)
4402 );
4403 } else {
4404 assert!(fills.is_empty());
4405 }
4406
4407 let canceled = events
4408 .iter()
4409 .filter(|event| {
4410 matches!(event, ExecutionEvent::Order(OrderEventAny::Canceled(canceled))
4411 if canceled.client_order_id == client_order_id
4412 && canceled.venue_order_id == Some(venue_order_id))
4413 })
4414 .count();
4415
4416 let expected_cancel = usize::from(
4417 order_status == PolymarketOrderStatus::Canceled
4418 && !locally_closed
4419 && !replacement_promoted,
4420 );
4421
4422 assert_eq!(canceled, expected_cancel);
4423 assert_eq!(
4424 events.len(),
4425 usize::from(expected_applied && !locally_closed && !replacement_promoted)
4426 + fills.len()
4427 + expected_cancel
4428 );
4429 }
4430
4431 #[rstest]
4432 fn test_apply_rest_trade_evidence_closes_ioc_remainder_on_confirmation() {
4433 let trade: PolymarketTradeReport =
4434 serde_json::from_str(include_str!("../../test_data/http_trade_report.json"))
4435 .expect("REST trade fixture");
4436 let ws_trade: PolymarketUserTrade = load("ws_user_trade.json");
4437 let instrument = instrument_for_trade(&ws_trade);
4438 let token_instruments = AtomicMap::new();
4439 token_instruments.insert(trade.asset_id, instrument.clone());
4440 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
4441 let fill_tracker = OrderFillTrackerMap::new();
4442 fill_tracker.register(
4443 venue_order_id,
4444 Quantity::from("100.0000"),
4445 OrderSide::Buy,
4446 instrument.id(),
4447 instrument.size_precision(),
4448 instrument.price_precision(),
4449 );
4450 let pending_submits = PendingSubmitTracker::default();
4451 let order_contexts = OrderContextRegistry::default();
4452 register_context(&order_contexts, venue_order_id, instrument.id(), "O-IOC");
4453 let mut context = order_contexts
4454 .get(&venue_order_id)
4455 .expect("registered context");
4456 context.time_in_force = TimeInForce::Ioc;
4457 order_contexts.register_context(venue_order_id, context);
4458 order_contexts.mark_accepted(venue_order_id);
4459 let mut emitter = test_emitter();
4460 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
4461 emitter.set_sender(sender);
4462 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
4463 settlement.begin_session();
4464
4465 let ctx = WsDispatchContext {
4466 signer_type: PolymarketSignerType::Owner,
4467 token_instruments: &token_instruments,
4468 fill_tracker: &fill_tracker,
4469 settlement: &settlement,
4470 pending_submits: &pending_submits,
4471 order_contexts: &order_contexts,
4472 emitter: &emitter,
4473 account_id: AccountId::from("POLY-001"),
4474 clock: nautilus_core::time::get_atomic_clock_realtime(),
4475 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
4476 user_api_key: "00000000-0000-0000-0000-000000000001",
4477 };
4478 let mut state = WsDispatchState::default();
4479
4480 apply_rest_trade_evidence(&trade, &ctx, &mut state);
4481
4482 let filled = match receiver.try_recv().unwrap() {
4483 ExecutionEvent::Order(OrderEventAny::Filled(event)) => event,
4484 other => panic!("expected REST-confirmed fill, was {other:?}"),
4485 };
4486
4487 let canceled = match receiver.try_recv().unwrap() {
4488 ExecutionEvent::Order(OrderEventAny::Canceled(event)) => event,
4489 other => panic!("expected IOC remainder cancel, was {other:?}"),
4490 };
4491
4492 assert_eq!(filled.last_qty.as_decimal(), dec!(25));
4493 assert_eq!(filled.trade_id, TradeId::from(trade.id.as_str()));
4494 assert_eq!(canceled.client_order_id, ClientOrderId::from("O-IOC"));
4495 assert_eq!(canceled.venue_order_id, Some(venue_order_id));
4496 assert!(receiver.try_recv().is_err());
4497 assert_eq!(
4498 settlement_state(&settlement, &trade.id),
4499 Some(SettlementState::RestConfirmed)
4500 );
4501
4502 apply_rest_trade_evidence(&trade, &ctx, &mut state);
4503 assert!(receiver.try_recv().is_err());
4504 }
4505
4506 #[rstest]
4507 fn test_apply_rest_trade_evidence_normalizes_fok_dust_once() {
4508 let trade: PolymarketTradeReport =
4509 serde_json::from_str(include_str!("../../test_data/http_trade_report.json"))
4510 .expect("REST trade fixture");
4511 let ws_trade: PolymarketUserTrade = load("ws_user_trade.json");
4512 let instrument = instrument_for_trade(&ws_trade);
4513 let token_instruments = AtomicMap::new();
4514 token_instruments.insert(trade.asset_id, instrument.clone());
4515 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
4516 let submitted_qty = Quantity::from("25.005000");
4517 let fill_tracker = OrderFillTrackerMap::new();
4518 fill_tracker.register(
4519 venue_order_id,
4520 submitted_qty,
4521 OrderSide::Buy,
4522 instrument.id(),
4523 instrument.size_precision(),
4524 instrument.price_precision(),
4525 );
4526 let pending_submits = PendingSubmitTracker::default();
4527 let order_contexts = OrderContextRegistry::default();
4528 register_context(&order_contexts, venue_order_id, instrument.id(), "O-FOK");
4529 let mut context = order_contexts
4530 .get(&venue_order_id)
4531 .expect("registered context");
4532 context.time_in_force = TimeInForce::Fok;
4533 order_contexts.register_context(venue_order_id, context);
4534 order_contexts.mark_accepted(venue_order_id);
4535 let mut emitter = test_emitter();
4536 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
4537 emitter.set_sender(sender);
4538 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
4539 settlement.begin_session();
4540
4541 let ctx = WsDispatchContext {
4542 signer_type: PolymarketSignerType::Owner,
4543 token_instruments: &token_instruments,
4544 fill_tracker: &fill_tracker,
4545 settlement: &settlement,
4546 pending_submits: &pending_submits,
4547 order_contexts: &order_contexts,
4548 emitter: &emitter,
4549 account_id: AccountId::from("POLY-001"),
4550 clock: nautilus_core::time::get_atomic_clock_realtime(),
4551 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
4552 user_api_key: "00000000-0000-0000-0000-000000000001",
4553 };
4554 let mut state = WsDispatchState::default();
4555
4556 apply_rest_trade_evidence(&trade, &ctx, &mut state);
4557
4558 let filled = match receiver.try_recv().unwrap() {
4559 ExecutionEvent::Order(OrderEventAny::Filled(event)) => event,
4560 other => panic!("expected REST-confirmed fill, was {other:?}"),
4561 };
4562 let updated = match receiver.try_recv().unwrap() {
4563 ExecutionEvent::Order(OrderEventAny::Updated(event)) => event,
4564 other => panic!("expected FOK quantity normalization, was {other:?}"),
4565 };
4566
4567 assert_eq!(filled.last_qty.as_decimal(), dec!(25));
4568 assert_eq!(updated.quantity, filled.last_qty);
4569 assert_eq!(updated.client_order_id, ClientOrderId::from("O-FOK"));
4570 assert!(receiver.try_recv().is_err());
4571
4572 apply_rest_trade_evidence(&trade, &ctx, &mut state);
4573 assert!(receiver.try_recv().is_err());
4574 assert_eq!(
4575 settlement_state(&settlement, &trade.id),
4576 Some(SettlementState::RestConfirmed)
4577 );
4578 assert_eq!(trade_hard_fault(&settlement, &trade.id), None);
4579 }
4580
4581 struct TerminalFaultHarness {
4582 trade: PolymarketUserTrade,
4583 token_instruments: AtomicMap<Ustr, InstrumentAny>,
4584 venue_order_id: VenueOrderId,
4585 fill_tracker: OrderFillTrackerMap,
4586 pending_submits: PendingSubmitTracker,
4587 order_contexts: OrderContextRegistry,
4588 emitter: ExecutionEventEmitter,
4589 receiver: tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
4590 settlement: SettlementRegistry,
4591 fill: OrderFilled,
4592 }
4593
4594 impl TerminalFaultHarness {
4595 fn new(time_in_force: TimeInForce, submitted_qty: &str, client_order_id: &str) -> Self {
4596 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
4597 trade.status = PolymarketTradeStatus::Matched;
4598 let mut instrument = instrument_for_trade(&trade);
4599 set_taker_fee_rate(&mut instrument, dec!(0.0721));
4600 let token_instruments = AtomicMap::new();
4601 token_instruments.insert(trade.asset_id, instrument.clone());
4602 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
4603 let fill_tracker = OrderFillTrackerMap::new();
4604 fill_tracker.register(
4605 venue_order_id,
4606 Quantity::from(submitted_qty),
4607 OrderSide::Buy,
4608 instrument.id(),
4609 instrument.size_precision(),
4610 instrument.price_precision(),
4611 );
4612 let pending_submits = PendingSubmitTracker::default();
4613 pending_submits.insert(venue_order_id, ClientOrderId::from(client_order_id));
4614 let order_contexts = OrderContextRegistry::default();
4615 register_context(
4616 &order_contexts,
4617 venue_order_id,
4618 instrument.id(),
4619 client_order_id,
4620 );
4621 let mut context = order_contexts
4622 .get(&venue_order_id)
4623 .expect("registered context");
4624 context.time_in_force = time_in_force;
4625 order_contexts.register_context(venue_order_id, context);
4626 order_contexts.mark_accepted(venue_order_id);
4627 let mut emitter = test_emitter();
4628 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
4629 emitter.set_sender(sender);
4630 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
4631 settlement.begin_session();
4632 settlement.note_order_submitted(venue_order_id);
4633 let ctx = WsDispatchContext {
4634 signer_type: PolymarketSignerType::Owner,
4635 token_instruments: &token_instruments,
4636 fill_tracker: &fill_tracker,
4637 settlement: &settlement,
4638 pending_submits: &pending_submits,
4639 order_contexts: &order_contexts,
4640 emitter: &emitter,
4641 account_id: AccountId::from("POLY-001"),
4642 clock: nautilus_core::time::get_atomic_clock_realtime(),
4643 user_address: trade.maker_address.as_str(),
4644 user_api_key: trade.owner.as_str(),
4645 };
4646 let mut state = WsDispatchState::default();
4647 dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
4648 let fill = match receiver.try_recv().expect("matched fill") {
4649 ExecutionEvent::Order(OrderEventAny::Filled(fill)) => fill,
4650 other => panic!("expected matched fill, was {other:?}"),
4651 };
4652 settlement.observe_fill_applied(&fill);
4653 assert!(
4654 receiver.try_recv().is_err(),
4655 "provisional match emitted terminal bookkeeping"
4656 );
4657
4658 Self {
4659 trade,
4660 token_instruments,
4661 venue_order_id,
4662 fill_tracker,
4663 pending_submits,
4664 order_contexts,
4665 emitter,
4666 receiver,
4667 settlement,
4668 fill,
4669 }
4670 }
4671
4672 fn ctx(&self) -> WsDispatchContext<'_> {
4673 WsDispatchContext {
4674 signer_type: PolymarketSignerType::Owner,
4675 token_instruments: &self.token_instruments,
4676 fill_tracker: &self.fill_tracker,
4677 settlement: &self.settlement,
4678 pending_submits: &self.pending_submits,
4679 order_contexts: &self.order_contexts,
4680 emitter: &self.emitter,
4681 account_id: AccountId::from("POLY-001"),
4682 clock: nautilus_core::time::get_atomic_clock_realtime(),
4683 user_address: self.trade.maker_address.as_str(),
4684 user_api_key: self.trade.owner.as_str(),
4685 }
4686 }
4687
4688 fn contradicting_rest(&self) -> PolymarketTradeReport {
4689 let mut rest: PolymarketTradeReport = load("http_trade_report.json");
4690 rest.id = self.trade.id.clone();
4691 rest.taker_order_id = self.trade.taker_order_id.clone();
4692 rest.asset_id = self.trade.asset_id;
4693 rest.price = dec!(0.6);
4694 for maker in &mut rest.maker_orders {
4695 maker.price = rest.price;
4696 }
4697
4698 rest.status = PolymarketTradeStatus::Confirmed;
4699 rest
4700 }
4701 }
4702
4703 fn assert_no_fault_bookkeeping(events: &[ExecutionEvent]) {
4704 assert!(
4705 events.iter().all(|event| !matches!(
4706 event,
4707 ExecutionEvent::Order(
4708 OrderEventAny::Updated(_)
4709 | OrderEventAny::Canceled(_)
4710 | OrderEventAny::Filled(_)
4711 | OrderEventAny::FillVoided(_)
4712 )
4713 )),
4714 "faulted trade authorized bookkeeping, was {events:?}"
4715 );
4716 }
4717
4718 fn assert_fault_retained(harness: &TerminalFaultHarness) {
4719 assert_eq!(harness.fill.last_qty, Quantity::from("25.000000"));
4720 assert_eq!(harness.fill.last_px.as_decimal(), dec!(0.5));
4721 assert_eq!(harness.fill.commission.unwrap().as_decimal(), dec!(0.45062));
4722 assert_eq!(
4723 settlement_state(&harness.settlement, &harness.trade.id),
4724 Some(SettlementState::RestConfirmed)
4725 );
4726 assert!(trade_hard_fault(&harness.settlement, &harness.trade.id).is_some());
4727 assert!(harness.settlement.is_trade_confirmed(&harness.trade.id));
4728 assert!(
4729 harness
4730 .settlement
4731 .ensure_resolved(None, "mass status")
4732 .is_err()
4733 );
4734 assert!(harness.fill_tracker.contains(&harness.venue_order_id));
4735 }
4736
4737 #[rstest]
4738 #[case::fok_dust(TimeInForce::Fok, "25.005000", "O-FAULT-FOK")]
4739 #[case::ioc_partial(TimeInForce::Ioc, "100.000000", "O-FAULT-IOC")]
4740 fn test_contradicting_rest_does_not_authorize_terminal_bookkeeping(
4741 #[case] time_in_force: TimeInForce,
4742 #[case] submitted_qty: &str,
4743 #[case] client_order_id: &str,
4744 ) {
4745 let mut harness = TerminalFaultHarness::new(time_in_force, submitted_qty, client_order_id);
4746 let rest = harness.contradicting_rest();
4747 let mut state = WsDispatchState::default();
4748 {
4749 let ctx = harness.ctx();
4750 apply_rest_trade_evidence(&rest, &ctx, &mut state);
4751 apply_rest_trade_evidence(&rest, &ctx, &mut state);
4752 }
4753
4754 let events: Vec<_> = std::iter::from_fn(|| harness.receiver.try_recv().ok()).collect();
4755 assert_no_fault_bookkeeping(&events);
4756 assert_fault_retained(&harness);
4757 }
4758
4759 #[rstest]
4760 #[case::fok_dust(TimeInForce::Fok, "25.005000", "O-UNCERTAIN-FOK", PolymarketOrderType::FOK, dec!(25.005))]
4761 #[case::ioc_partial(TimeInForce::Ioc, "100.000000", "O-UNCERTAIN-IOC", PolymarketOrderType::FAK, dec!(100))]
4762 fn test_uncertain_filled_recovery_does_not_bypass_fault_guard(
4763 #[case] time_in_force: TimeInForce,
4764 #[case] submitted_qty: &str,
4765 #[case] client_order_id: &str,
4766 #[case] order_type: PolymarketOrderType,
4767 #[case] original_size: Decimal,
4768 ) {
4769 let mut harness = TerminalFaultHarness::new(time_in_force, submitted_qty, client_order_id);
4770 let rest = harness.contradicting_rest();
4771 let mut order: PolymarketOpenOrder =
4772 serde_json::from_str(include_str!("../../test_data/http_open_order.json"))
4773 .expect("REST open order fixture");
4774 order.status = PolymarketOrderStatus::Matched;
4775 order.order_type = order_type;
4776 order.original_size = original_size;
4777 order.size_matched = dec!(25);
4778 let mut state = WsDispatchState::default();
4779 let applied = {
4780 let ctx = harness.ctx();
4781 apply_uncertain_order_evidence(
4782 harness.venue_order_id,
4783 &order,
4784 std::slice::from_ref(&rest),
4785 &ctx,
4786 &mut state,
4787 )
4788 };
4789
4790 let events: Vec<_> = std::iter::from_fn(|| harness.receiver.try_recv().ok()).collect();
4791 assert!(applied);
4792 assert_no_fault_bookkeeping(&events);
4793 assert_fault_retained(&harness);
4794 }
4795
4796 #[rstest]
4797 fn test_uncertain_venue_cancel_still_emits_after_hard_fault() {
4798 let mut harness =
4799 TerminalFaultHarness::new(TimeInForce::Fok, "25.005000", "O-VENUE-CANCEL");
4800 let rest = harness.contradicting_rest();
4801 let mut state = WsDispatchState::default();
4802 {
4803 let ctx = harness.ctx();
4804 apply_rest_trade_evidence(&rest, &ctx, &mut state);
4805 }
4806 let fault_events: Vec<_> =
4807 std::iter::from_fn(|| harness.receiver.try_recv().ok()).collect();
4808 assert_no_fault_bookkeeping(&fault_events);
4809
4810 let mut order: PolymarketOpenOrder =
4811 serde_json::from_str(include_str!("../../test_data/http_open_order.json"))
4812 .expect("REST open order fixture");
4813 order.status = PolymarketOrderStatus::Canceled;
4814 order.order_type = PolymarketOrderType::FAK;
4815 order.original_size = dec!(100);
4816 order.size_matched = dec!(25);
4817 let applied = {
4818 let ctx = harness.ctx();
4819 apply_uncertain_order_evidence(
4820 harness.venue_order_id,
4821 &order,
4822 std::slice::from_ref(&rest),
4823 &ctx,
4824 &mut state,
4825 )
4826 };
4827 let canceled = match harness.receiver.try_recv().expect("venue cancel") {
4828 ExecutionEvent::Order(OrderEventAny::Canceled(event)) => event,
4829 other => panic!("expected venue cancel, was {other:?}"),
4830 };
4831
4832 assert!(applied);
4833 assert_eq!(
4834 canceled.client_order_id,
4835 ClientOrderId::from("O-VENUE-CANCEL")
4836 );
4837 assert_eq!(canceled.venue_order_id, Some(harness.venue_order_id));
4838 assert!(harness.receiver.try_recv().is_err());
4839 assert_fault_retained(&harness);
4840 }
4841
4842 #[rstest]
4843 fn test_apply_uncertain_order_evidence_normalizes_filled_fok_dust() {
4844 let mut order: PolymarketOpenOrder =
4845 serde_json::from_str(include_str!("../../test_data/http_open_order.json"))
4846 .expect("REST open order fixture");
4847 order.status = PolymarketOrderStatus::Matched;
4848 order.original_size = dec!(25.005);
4849 order.size_matched = dec!(25);
4850 let trade: PolymarketTradeReport =
4851 serde_json::from_str(include_str!("../../test_data/http_trade_report.json"))
4852 .expect("REST trade fixture");
4853 let ws_trade: PolymarketUserTrade = load("ws_user_trade.json");
4854 let instrument = instrument_for_trade(&ws_trade);
4855 let token_instruments = AtomicMap::new();
4856 token_instruments.insert(order.asset_id, instrument.clone());
4857 let venue_order_id = VenueOrderId::from(order.id.as_str());
4858 let client_order_id = ClientOrderId::from("O-FOK");
4859 let fill_tracker = OrderFillTrackerMap::new();
4860 let pending_submits = PendingSubmitTracker::default();
4861 pending_submits.insert(venue_order_id, client_order_id);
4862 let order_contexts = OrderContextRegistry::default();
4863 register_context(
4864 &order_contexts,
4865 venue_order_id,
4866 instrument.id(),
4867 client_order_id.as_str(),
4868 );
4869 let mut context = order_contexts
4870 .get(&venue_order_id)
4871 .expect("registered context");
4872 context.time_in_force = TimeInForce::Fok;
4873 order_contexts.register_context(venue_order_id, context);
4874 let mut emitter = test_emitter();
4875 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
4876 emitter.set_sender(sender);
4877 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
4878 settlement.begin_session();
4879
4880 let ctx = WsDispatchContext {
4881 signer_type: PolymarketSignerType::Owner,
4882 token_instruments: &token_instruments,
4883 fill_tracker: &fill_tracker,
4884 settlement: &settlement,
4885 pending_submits: &pending_submits,
4886 order_contexts: &order_contexts,
4887 emitter: &emitter,
4888 account_id: AccountId::from("POLY-001"),
4889 clock: nautilus_core::time::get_atomic_clock_realtime(),
4890 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
4891 user_api_key: "00000000-0000-0000-0000-000000000001",
4892 };
4893 let mut state = WsDispatchState::default();
4894
4895 let applied = apply_uncertain_order_evidence(
4896 venue_order_id,
4897 &order,
4898 std::slice::from_ref(&trade),
4899 &ctx,
4900 &mut state,
4901 );
4902
4903 let mut events = Vec::new();
4904
4905 while let Ok(ExecutionEvent::Order(event)) = receiver.try_recv() {
4906 events.push(event);
4907 }
4908
4909 assert!(applied);
4910 assert_eq!(events.len(), 3, "unexpected events: {events:?}");
4911 assert!(matches!(&events[0], OrderEventAny::Accepted(_)));
4912
4913 let OrderEventAny::Filled(filled) = &events[1] else {
4914 panic!("expected fill, was {:?}", events[1]);
4915 };
4916
4917 let OrderEventAny::Updated(updated) = &events[2] else {
4918 panic!("expected terminal quantity update, was {:?}", events[2]);
4919 };
4920
4921 assert_eq!(filled.last_qty.as_decimal(), dec!(25));
4922 assert_eq!(updated.client_order_id, client_order_id);
4923 assert_eq!(updated.quantity.as_decimal(), dec!(25));
4924
4925 let repeated = apply_uncertain_order_evidence(
4926 venue_order_id,
4927 &order,
4928 std::slice::from_ref(&trade),
4929 &ctx,
4930 &mut state,
4931 );
4932 assert!(repeated);
4933 assert!(receiver.try_recv().is_err());
4934 }
4935
4936 #[rstest]
4937 #[case::identical_repeat(dec!(25), dec!(50))]
4938 #[case::contradicting_repeat(dec!(10), dec!(25))]
4939 fn test_apply_uncertain_order_evidence_deduplicates_repeated_rows(
4940 #[case] repeat_size: Decimal,
4941 #[case] size_matched: Decimal,
4942 ) {
4943 let mut order: PolymarketOpenOrder =
4944 serde_json::from_str(include_str!("../../test_data/http_open_order.json"))
4945 .expect("REST open order fixture");
4946 order.status = PolymarketOrderStatus::Matched;
4947 order.original_size = size_matched;
4948 order.size_matched = size_matched;
4949 let trade: PolymarketTradeReport =
4950 serde_json::from_str(include_str!("../../test_data/http_trade_report.json"))
4951 .expect("REST trade fixture");
4952 let mut repeat = trade.clone();
4953 repeat.size = repeat_size;
4954 let ws_trade: PolymarketUserTrade = load("ws_user_trade.json");
4955 let instrument = instrument_for_trade(&ws_trade);
4956 let token_instruments = AtomicMap::new();
4957 token_instruments.insert(order.asset_id, instrument.clone());
4958 let venue_order_id = VenueOrderId::from(order.id.as_str());
4959 let fill_tracker = OrderFillTrackerMap::new();
4960 let pending_submits = PendingSubmitTracker::default();
4961 pending_submits.insert(venue_order_id, ClientOrderId::from("O-UNCERTAIN"));
4962 let order_contexts = OrderContextRegistry::default();
4963 register_context(
4964 &order_contexts,
4965 venue_order_id,
4966 instrument.id(),
4967 "O-UNCERTAIN",
4968 );
4969 let mut emitter = test_emitter();
4970 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
4971 emitter.set_sender(sender);
4972 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
4973 settlement.begin_session();
4974
4975 let ctx = WsDispatchContext {
4976 signer_type: PolymarketSignerType::Owner,
4977 token_instruments: &token_instruments,
4978 fill_tracker: &fill_tracker,
4979 settlement: &settlement,
4980 pending_submits: &pending_submits,
4981 order_contexts: &order_contexts,
4982 emitter: &emitter,
4983 account_id: AccountId::from("POLY-001"),
4984 clock: nautilus_core::time::get_atomic_clock_realtime(),
4985 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
4986 user_api_key: "00000000-0000-0000-0000-000000000001",
4987 };
4988 let mut state = WsDispatchState::default();
4989
4990 let applied = apply_uncertain_order_evidence(
4991 venue_order_id,
4992 &order,
4993 &[trade, repeat],
4994 &ctx,
4995 &mut state,
4996 );
4997
4998 assert!(!applied);
4999 assert!(!fill_tracker.contains(&venue_order_id));
5000 assert!(receiver.try_recv().is_err());
5001 }
5002
5003 #[rstest]
5004 #[case::other_venue_order_id(Some("0xother"), PolymarketOrderSide::Buy)]
5005 #[case::contradicting_side(None, PolymarketOrderSide::Sell)]
5006 fn test_apply_uncertain_order_evidence_rejects_contradicting_row(
5007 #[case] row_id: Option<&str>,
5008 #[case] row_side: PolymarketOrderSide,
5009 ) {
5010 let mut order: PolymarketOpenOrder =
5011 serde_json::from_str(include_str!("../../test_data/http_open_order.json"))
5012 .expect("REST open order fixture");
5013 let venue_order_id = VenueOrderId::from(order.id.as_str());
5014
5015 if let Some(row_id) = row_id {
5016 order.id = row_id.to_string();
5017 }
5018
5019 order.side = row_side;
5020 let ws_trade: PolymarketUserTrade = load("ws_user_trade.json");
5021 let instrument = instrument_for_trade(&ws_trade);
5022 let token_instruments = AtomicMap::new();
5023 token_instruments.insert(order.asset_id, instrument.clone());
5024 let fill_tracker = OrderFillTrackerMap::new();
5025 let pending_submits = PendingSubmitTracker::default();
5026 pending_submits.insert(venue_order_id, ClientOrderId::from("O-UNCERTAIN"));
5027 let order_contexts = OrderContextRegistry::default();
5028 register_context(
5029 &order_contexts,
5030 venue_order_id,
5031 instrument.id(),
5032 "O-UNCERTAIN",
5033 );
5034 let mut emitter = test_emitter();
5035 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
5036 emitter.set_sender(sender);
5037 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
5038
5039 let ctx = WsDispatchContext {
5040 signer_type: PolymarketSignerType::Owner,
5041 token_instruments: &token_instruments,
5042 fill_tracker: &fill_tracker,
5043 settlement: &settlement,
5044 pending_submits: &pending_submits,
5045 order_contexts: &order_contexts,
5046 emitter: &emitter,
5047 account_id: AccountId::from("POLY-001"),
5048 clock: nautilus_core::time::get_atomic_clock_realtime(),
5049 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
5050 user_api_key: "00000000-0000-0000-0000-000000000001",
5051 };
5052 let mut state = WsDispatchState::default();
5053
5054 let applied = apply_uncertain_order_evidence(venue_order_id, &order, &[], &ctx, &mut state);
5055
5056 assert!(!applied);
5057 assert!(!fill_tracker.contains(&venue_order_id));
5058 assert!(receiver.try_recv().is_err());
5059 }
5060
5061 #[rstest]
5062 fn test_apply_stream_gap_order_evidence_applies_only_unseen_trades() {
5063 let mut order: PolymarketOpenOrder =
5064 serde_json::from_str(include_str!("../../test_data/http_open_order.json"))
5065 .expect("REST open order fixture");
5066 order.status = PolymarketOrderStatus::Canceled;
5067 order.original_size = dec!(100);
5068 order.size_matched = dec!(50);
5069 let seen: PolymarketTradeReport =
5070 serde_json::from_str(include_str!("../../test_data/http_trade_report.json"))
5071 .expect("REST trade fixture");
5072 let mut unseen = seen.clone();
5073 unseen.id = "trade-0xunseen".to_string();
5074 let trades = vec![seen.clone(), unseen.clone()];
5075 let ws_trade: PolymarketUserTrade = load("ws_user_trade.json");
5076 let instrument = instrument_for_trade(&ws_trade);
5077 let token_instruments = AtomicMap::new();
5078 token_instruments.insert(order.asset_id, instrument.clone());
5079 let venue_order_id = VenueOrderId::from(order.id.as_str());
5080 let client_order_id = ClientOrderId::from("O-STREAM-GAP");
5081 let fill_tracker = OrderFillTrackerMap::new();
5082 fill_tracker.register(
5083 venue_order_id,
5084 Quantity::from("100.0000"),
5085 OrderSide::Buy,
5086 instrument.id(),
5087 instrument.size_precision(),
5088 instrument.price_precision(),
5089 );
5090 let pending_submits = PendingSubmitTracker::default();
5091 pending_submits.insert(venue_order_id, client_order_id);
5092 let order_contexts = OrderContextRegistry::default();
5093 register_context(
5094 &order_contexts,
5095 venue_order_id,
5096 instrument.id(),
5097 client_order_id.as_str(),
5098 );
5099 order_contexts.mark_accepted(venue_order_id);
5100 let mut emitter = test_emitter();
5101 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
5102 emitter.set_sender(sender);
5103 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
5104 settlement.begin_session();
5105
5106 settlement.hydrate_fill(&OrderFilled::new(
5108 TraderId::from("TESTER-001"),
5109 StrategyId::from("S-001"),
5110 instrument.id(),
5111 client_order_id,
5112 venue_order_id,
5113 AccountId::from("POLY-001"),
5114 TradeId::from(seen.id.as_str()),
5115 OrderSide::Buy,
5116 OrderType::Limit,
5117 Quantity::from("24.9900"),
5118 Price::from("0.5000"),
5119 Currency::pUSD(),
5120 LiquiditySide::Taker,
5121 UUID4::new(),
5122 UnixNanos::from(1_u64),
5123 UnixNanos::from(1_u64),
5124 false,
5125 None,
5126 None,
5127 None,
5128 ));
5129
5130 let ctx = WsDispatchContext {
5131 signer_type: PolymarketSignerType::Owner,
5132 token_instruments: &token_instruments,
5133 fill_tracker: &fill_tracker,
5134 settlement: &settlement,
5135 pending_submits: &pending_submits,
5136 order_contexts: &order_contexts,
5137 emitter: &emitter,
5138 account_id: AccountId::from("POLY-001"),
5139 clock: nautilus_core::time::get_atomic_clock_realtime(),
5140 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
5141 user_api_key: "00000000-0000-0000-0000-000000000001",
5142 };
5143
5144 let mut state = WsDispatchState::default();
5145
5146 let applied =
5147 apply_stream_gap_order_evidence(venue_order_id, &order, &trades, &ctx, &mut state);
5148
5149 let mut events = Vec::new();
5150
5151 while let Ok(event) = receiver.try_recv() {
5152 events.push(event);
5153 }
5154
5155 let ExecutionEvent::Order(OrderEventAny::Filled(filled)) = &events[0] else {
5156 panic!("expected the unseen trade's fill, was {:?}", events[0]);
5157 };
5158
5159 assert!(applied);
5160 assert_eq!(events.len(), 1);
5161 assert_eq!(filled.client_order_id, client_order_id);
5162 assert_eq!(filled.venue_order_id, venue_order_id);
5163 assert_eq!(filled.trade_id, TradeId::from(unseen.id.as_str()));
5164 assert_eq!(filled.last_qty.as_decimal(), dec!(25));
5165 assert_eq!(filled.last_px.as_decimal(), dec!(0.5));
5166 assert_eq!(
5167 settlement_state(&settlement, &unseen.id),
5168 Some(SettlementState::RestConfirmed)
5169 );
5170 assert_eq!(
5171 settlement_state(&settlement, &seen.id),
5172 Some(SettlementState::Provisional)
5173 );
5174 assert!(trade_hard_fault(&settlement, &seen.id).is_none());
5175 }
5176
5177 #[rstest]
5178 fn test_dispatch_matched_trade_emits_fill_and_failed_trade_quarantines_then_rest_voids_it() {
5179 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
5180 trade.status = crate::common::enums::PolymarketTradeStatus::Matched;
5181 let instrument = instrument_for_trade(&trade);
5182 let token_instruments = AtomicMap::new();
5183 token_instruments.insert(trade.asset_id, instrument.clone());
5184 let fill_tracker = OrderFillTrackerMap::new();
5185 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
5186 fill_tracker.register(
5187 venue_order_id,
5188 Quantity::from("100"),
5189 OrderSide::Buy,
5190 instrument.id(),
5191 instrument.size_precision(),
5192 instrument.price_precision(),
5193 );
5194 let pending_submits = PendingSubmitTracker::default();
5195 let order_contexts = OrderContextRegistry::default();
5196 register_context(
5197 &order_contexts,
5198 venue_order_id,
5199 instrument.id(),
5200 "O-MATCHED-FAILED",
5201 );
5202 order_contexts.mark_accepted(venue_order_id);
5203 let mut emitter = test_emitter();
5204 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
5205 emitter.set_sender(sender);
5206 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
5207 settlement.mark_live();
5208 settlement.note_order_submitted(venue_order_id);
5209
5210 let ctx = WsDispatchContext {
5211 signer_type: PolymarketSignerType::Owner,
5212 token_instruments: &token_instruments,
5213 fill_tracker: &fill_tracker,
5214 settlement: &settlement,
5215 pending_submits: &pending_submits,
5216 order_contexts: &order_contexts,
5217 emitter: &emitter,
5218 account_id: AccountId::from("POLY-001"),
5219 clock: nautilus_core::time::get_atomic_clock_realtime(),
5220 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
5221 user_api_key: "00000000-0000-0000-0000-000000000001",
5222 };
5223 let mut state = WsDispatchState::default();
5224
5225 let matched = dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
5227 let filled = match receiver.try_recv().unwrap() {
5228 ExecutionEvent::Order(OrderEventAny::Filled(event)) => event,
5229 other => panic!("expected matched fill, was {other:?}"),
5230 };
5231
5232 assert!(matched.is_none());
5233 assert_eq!(
5234 settlement_state(&settlement, &trade.id),
5235 Some(SettlementState::Provisional)
5236 );
5237
5238 settlement.observe_fill_applied(&filled);
5240
5241 trade.status = crate::common::enums::PolymarketTradeStatus::Failed;
5243 let failed = dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
5244 assert!(failed.is_none());
5245 assert_eq!(
5246 settlement_state(&settlement, &trade.id),
5247 Some(SettlementState::Quarantined)
5248 );
5249 assert!(receiver.try_recv().is_err());
5250 assert_eq!(
5251 fill_tracker.get_cumulative_filled(&venue_order_id),
5252 Some(filled.last_qty)
5253 );
5254
5255 let mut rest_failed: PolymarketTradeReport =
5257 serde_json::from_str(include_str!("../../test_data/http_trade_report.json"))
5258 .expect("REST trade fixture");
5259 rest_failed.id = trade.id.clone();
5260 rest_failed.taker_order_id = trade.taker_order_id.clone();
5261 rest_failed.status = PolymarketTradeStatus::Failed;
5262 rest_failed.trader_side = PolymarketLiquiditySide::Taker;
5263 let rest_evidence =
5264 admit_trade_evidence(TradeEvidence::Rest(&rest_failed), &ctx.admission_context())
5265 .expect("REST FAILED evidence admits");
5266 let rest_actions = settlement.admit_rest_result(&rest_evidence);
5267 execute_settlement_actions(
5268 rest_actions,
5269 rest_trade_info(&rest_failed).as_ref(),
5270 &ctx,
5271 &mut state,
5272 );
5273
5274 let voided = match receiver.try_recv().unwrap() {
5275 ExecutionEvent::Order(OrderEventAny::FillVoided(event)) => event,
5276 other => panic!("expected failed fill correction, was {other:?}"),
5277 };
5278
5279 assert!(settlement.take_account_refresh());
5280 assert!(trade_hard_fault(&settlement, &trade.id).is_none());
5281 assert_eq!(
5282 settlement_state(&settlement, &trade.id),
5283 Some(SettlementState::RestFailed)
5284 );
5285 assert_eq!(voided.trade_id, filled.trade_id);
5286 assert_eq!(voided.voided_qty, filled.last_qty);
5287 assert_eq!(voided.commission_voided, filled.commission);
5288 assert_eq!(voided.last_px, filled.last_px);
5289 assert!(!voided.is_reopened);
5290 assert_eq!(voided.causation_id, Some(filled.event_id));
5291 assert_eq!(
5292 fill_tracker.get_cumulative_filled(&venue_order_id),
5293 Some(Quantity::zero(instrument.size_precision()))
5294 );
5295
5296 trade.status = PolymarketTradeStatus::Matched;
5298 let stale_trade_id = trade.id.clone();
5299 let matched_after_failure =
5300 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
5301 assert!(matched_after_failure.is_none());
5302 assert_eq!(
5303 settlement_state(&settlement, &stale_trade_id),
5304 Some(SettlementState::RestFailed)
5305 );
5306 assert!(receiver.try_recv().is_err());
5307 }
5308
5309 #[rstest]
5310 fn test_dispatch_trade_uses_pending_submit_client_order_id() {
5311 let trade: PolymarketUserTrade = load("ws_user_trade.json");
5312 let instrument = instrument_for_trade(&trade);
5313
5314 let token_instruments = AtomicMap::new();
5315 token_instruments.insert(trade.asset_id, instrument);
5316
5317 let fill_tracker = OrderFillTrackerMap::new();
5318 let pending_submits = PendingSubmitTracker::default();
5319 let order_contexts = OrderContextRegistry::default();
5320 let emitter = test_emitter();
5321
5322 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
5323 let client_order_id = ClientOrderId::from("O-UNKNOWN-FILL");
5324 pending_submits.insert(venue_order_id, client_order_id);
5325
5326 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
5327 settlement.mark_live();
5328 settlement.note_order_submitted(venue_order_id);
5329
5330 let ctx = WsDispatchContext {
5331 signer_type: PolymarketSignerType::Owner,
5332 token_instruments: &token_instruments,
5333 fill_tracker: &fill_tracker,
5334 settlement: &settlement,
5335 pending_submits: &pending_submits,
5336 order_contexts: &order_contexts,
5337 emitter: &emitter,
5338 account_id: AccountId::from("POLY-001"),
5339 clock: nautilus_core::time::get_atomic_clock_realtime(),
5340 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
5341 user_api_key: "00000000-0000-0000-0000-000000000001",
5342 };
5343 let mut state = WsDispatchState::default();
5344
5345 let _ = dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
5346
5347 let fills = fill_tracker.pending_fills_for(&venue_order_id);
5348 assert_eq!(fills[0].client_order_id, Some(client_order_id));
5349 }
5350
5351 #[rstest]
5352 fn test_dispatch_late_fill_stays_tracked_after_later_registrations() {
5353 let trade: PolymarketUserTrade = load("ws_user_trade.json");
5354 let market: GammaMarket = load("gamma_market_sports_market_money_line.json");
5355 let defs = parse_gamma_market(&market).unwrap();
5356 let instrument = bind_instrument(
5357 create_instrument_from_def(&defs[0], UnixNanos::from(1_000_000_000u64)).unwrap(),
5358 trade.market.as_str(),
5359 trade.outcome,
5360 );
5361 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
5362
5363 let token_instruments = AtomicMap::new();
5364 token_instruments.insert(trade.asset_id, instrument.clone());
5365
5366 let fill_tracker = OrderFillTrackerMap::new();
5367 fill_tracker.register(
5368 venue_order_id,
5369 Quantity::from("100"),
5370 OrderSide::Buy,
5371 instrument.id(),
5372 instrument.size_precision(),
5373 instrument.price_precision(),
5374 );
5375
5376 let pending_submits = PendingSubmitTracker::default();
5377 let order_contexts = OrderContextRegistry::default();
5378 register_context(
5379 &order_contexts,
5380 venue_order_id,
5381 instrument.id(),
5382 "O-LATE-FILL",
5383 );
5384 order_contexts.mark_accepted(venue_order_id);
5385 assert!(order_contexts.get(&venue_order_id).is_some());
5386
5387 for index in 0..10_000 {
5388 let later_venue_order_id = VenueOrderId::from(format!("V-LATER-{index}").as_str());
5389 let later_client_order_id = format!("O-LATER-{index}");
5390 register_context(
5391 &order_contexts,
5392 later_venue_order_id,
5393 instrument.id(),
5394 &later_client_order_id,
5395 );
5396 order_contexts.mark_accepted(later_venue_order_id);
5397 fill_tracker.register(
5398 later_venue_order_id,
5399 Quantity::from("1"),
5400 OrderSide::Sell,
5401 instrument.id(),
5402 instrument.size_precision(),
5403 instrument.price_precision(),
5404 );
5405 }
5406 assert!(order_contexts.get(&venue_order_id).is_some());
5407 assert!(fill_tracker.contains(&venue_order_id));
5408
5409 let mut emitter = test_emitter();
5410 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
5411 emitter.set_sender(sender);
5412
5413 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
5414 settlement.mark_live();
5415 settlement.note_order_submitted(venue_order_id);
5416
5417 let ctx = WsDispatchContext {
5418 signer_type: PolymarketSignerType::Owner,
5419 token_instruments: &token_instruments,
5420 fill_tracker: &fill_tracker,
5421 settlement: &settlement,
5422 pending_submits: &pending_submits,
5423 order_contexts: &order_contexts,
5424 emitter: &emitter,
5425 account_id: AccountId::from("POLY-001"),
5426 clock: nautilus_core::time::get_atomic_clock_realtime(),
5427 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
5428 user_api_key: "00000000-0000-0000-0000-000000000001",
5429 };
5430 let mut state = WsDispatchState::default();
5431
5432 dispatch_user_message(&UserWsMessage::Trade(trade.clone()), &ctx, &mut state);
5433
5434 let event = receiver.try_recv().expect("expected tracked late fill");
5435 let ExecutionEvent::Order(OrderEventAny::Filled(filled)) = event else {
5436 panic!("expected tracked OrderFilled after later registrations, was {event:?}");
5437 };
5438
5439 assert_eq!(filled.client_order_id, ClientOrderId::from("O-LATE-FILL"));
5440 assert_eq!(filled.venue_order_id, venue_order_id);
5441 assert_eq!(filled.trade_id, TradeId::from(trade.id.as_str()));
5442 assert_eq!(filled.instrument_id, instrument.id());
5443 assert_eq!(
5444 filled.last_qty.as_decimal(),
5445 Decimal::from_str_exact(&trade.size).unwrap()
5446 );
5447 assert_eq!(
5448 filled.last_px.as_decimal(),
5449 Decimal::from_str_exact(&trade.price).unwrap()
5450 );
5451 assert_eq!(filled.order_side, OrderSide::Buy);
5452 assert_eq!(filled.liquidity_side, LiquiditySide::Taker);
5453 let commission = filled.commission.expect("tracked fill has commission");
5454 assert_eq!(commission.as_decimal(), dec!(0.1875));
5455 assert_eq!(commission.currency, Currency::pUSD());
5456 assert!(receiver.try_recv().is_err());
5457 }
5458
5459 #[rstest]
5460 fn test_dispatch_order_matched_caps_filled_qty_when_no_trades_tracked() {
5461 let order: PolymarketUserOrder = load("ws_user_order_matched.json");
5462 let instrument = test_instrument();
5463
5464 let token_instruments = AtomicMap::new();
5465 token_instruments.insert(order.asset_id, instrument.clone());
5466
5467 let fill_tracker = OrderFillTrackerMap::new();
5468 let venue_order_id = VenueOrderId::from(order.id.as_str());
5469
5470 fill_tracker.register(
5472 venue_order_id,
5473 Quantity::from("100"),
5474 OrderSide::Buy,
5475 instrument.id(),
5476 instrument.size_precision(),
5477 instrument.price_precision(),
5478 );
5479
5480 let pending_submits = PendingSubmitTracker::default();
5481 let order_contexts = OrderContextRegistry::default();
5484 let mut emitter = test_emitter();
5485 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
5486 emitter.set_sender(sender);
5487
5488 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
5489 settlement.mark_live();
5490 settlement.note_order_submitted(venue_order_id);
5491
5492 let ctx = WsDispatchContext {
5493 signer_type: PolymarketSignerType::Owner,
5494 token_instruments: &token_instruments,
5495 fill_tracker: &fill_tracker,
5496 settlement: &settlement,
5497 pending_submits: &pending_submits,
5498 order_contexts: &order_contexts,
5499 emitter: &emitter,
5500 account_id: AccountId::from("POLY-001"),
5501 clock: nautilus_core::time::get_atomic_clock_realtime(),
5502 user_address: "0xtest",
5503 user_api_key: "test-key",
5504 };
5505 let mut state = WsDispatchState::default();
5506
5507 dispatch_user_message(&UserWsMessage::Order(order), &ctx, &mut state);
5508
5509 let event = receiver.try_recv().expect("Expected report");
5510 match event {
5511 ExecutionEvent::Report(report) => match report {
5512 ExecutionReport::Order(order_report) => {
5513 assert_eq!(order_report.filled_qty, Quantity::from("0"));
5514 }
5515 other => panic!("Expected order report, was {other:?}"),
5516 },
5517 other => panic!("Expected report event, was {other:?}"),
5518 }
5519 }
5520
5521 #[rstest]
5522 fn test_dispatch_order_matched_uses_tracked_fills_for_filled_qty() {
5523 let order: PolymarketUserOrder = load("ws_user_order_matched.json");
5524 let instrument = test_instrument();
5525
5526 let token_instruments = AtomicMap::new();
5527 token_instruments.insert(order.asset_id, instrument.clone());
5528
5529 let fill_tracker = OrderFillTrackerMap::new();
5530 let venue_order_id = VenueOrderId::from(order.id.as_str());
5531
5532 fill_tracker.register(
5534 venue_order_id,
5535 Quantity::from("100"),
5536 OrderSide::Buy,
5537 instrument.id(),
5538 instrument.size_precision(),
5539 instrument.price_precision(),
5540 );
5541 fill_tracker.record_fill(&venue_order_id, Quantity::new(50.0, 6));
5542
5543 let pending_submits = PendingSubmitTracker::default();
5544 let order_contexts = OrderContextRegistry::default();
5547 let mut emitter = test_emitter();
5548 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
5549 emitter.set_sender(sender);
5550
5551 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
5552 settlement.mark_live();
5553 settlement.note_order_submitted(venue_order_id);
5554
5555 let ctx = WsDispatchContext {
5556 signer_type: PolymarketSignerType::Owner,
5557 token_instruments: &token_instruments,
5558 fill_tracker: &fill_tracker,
5559 settlement: &settlement,
5560 pending_submits: &pending_submits,
5561 order_contexts: &order_contexts,
5562 emitter: &emitter,
5563 account_id: AccountId::from("POLY-001"),
5564 clock: nautilus_core::time::get_atomic_clock_realtime(),
5565 user_address: "0xtest",
5566 user_api_key: "test-key",
5567 };
5568 let mut state = WsDispatchState::default();
5569
5570 dispatch_user_message(&UserWsMessage::Order(order), &ctx, &mut state);
5571
5572 let event = receiver.try_recv().expect("Expected report");
5573 match event {
5574 ExecutionEvent::Report(report) => match report {
5575 ExecutionReport::Order(order_report) => {
5576 assert_eq!(order_report.filled_qty, Quantity::from("50"));
5577 }
5578 other => panic!("Expected order report, was {other:?}"),
5579 },
5580 other => panic!("Expected report event, was {other:?}"),
5581 }
5582 }
5583
5584 #[rstest]
5585 fn test_dispatch_order_matched_normalizes_quantity_without_fill() {
5586 let order: PolymarketUserOrder = load("ws_user_order_matched.json");
5587 let instrument = test_instrument();
5588
5589 let token_instruments = AtomicMap::new();
5590 token_instruments.insert(order.asset_id, instrument.clone());
5591
5592 let fill_tracker = OrderFillTrackerMap::new();
5593 let venue_order_id = VenueOrderId::from(order.id.as_str());
5594 fill_tracker.register(
5595 venue_order_id,
5596 Quantity::from("100"),
5597 OrderSide::Buy,
5598 instrument.id(),
5599 instrument.size_precision(),
5600 instrument.price_precision(),
5601 );
5602 fill_tracker.record_fill(&venue_order_id, Quantity::new(99.995, 6));
5603
5604 let pending_submits = PendingSubmitTracker::default();
5605 let order_contexts = OrderContextRegistry::default();
5606 register_context(
5607 &order_contexts,
5608 venue_order_id,
5609 instrument.id(),
5610 "O-MATCHED",
5611 );
5612 order_contexts.mark_accepted(venue_order_id);
5613 let mut emitter = test_emitter();
5614 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
5615 emitter.set_sender(sender);
5616
5617 let clock = Box::leak(Box::new(AtomicTime::new(
5618 false,
5619 UnixNanos::from(2_000_000_000u64),
5620 )));
5621
5622 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
5623 settlement.mark_live();
5624 settlement.note_order_submitted(venue_order_id);
5625
5626 let ctx = WsDispatchContext {
5627 signer_type: PolymarketSignerType::Owner,
5628 token_instruments: &token_instruments,
5629 fill_tracker: &fill_tracker,
5630 settlement: &settlement,
5631 pending_submits: &pending_submits,
5632 order_contexts: &order_contexts,
5633 emitter: &emitter,
5634 account_id: AccountId::from("POLY-001"),
5635 clock,
5636 user_address: "0xtest",
5637 user_api_key: "test-key",
5638 };
5639 let mut state = WsDispatchState::default();
5640
5641 let _ = settlement.admit_rest_result(&AdmittedTrade {
5642 venue_trade_id: "trade-0xfill1".to_string(),
5643 status: PolymarketTradeStatus::Confirmed,
5644 legs: Vec::new(),
5645 });
5646
5647 dispatch_user_message(&UserWsMessage::Order(order), &ctx, &mut state);
5648
5649 let event = receiver.try_recv().expect("expected quantity update");
5650 match event {
5651 ExecutionEvent::Order(OrderEventAny::Updated(updated)) => {
5652 assert_eq!(
5653 updated.ts_event,
5654 UnixNanos::from(1_703_875_201_000_000_000u64)
5655 );
5656 assert_eq!(updated.ts_init, UnixNanos::from(2_000_000_000u64));
5657 assert_eq!(updated.quantity, Quantity::new(99.995, 6));
5658 assert!(updated.reconciliation);
5659 }
5660 other => panic!("expected updated event, was {other:?}"),
5661 }
5662 assert!(receiver.try_recv().is_err());
5663 }
5664
5665 #[rstest]
5666 fn test_confirmed_trade_normalizes_pending_matched_quantity() {
5667 let mut order: PolymarketUserOrder = load("ws_user_order_matched.json");
5668 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
5669 let instrument = instrument_for_trade(&trade);
5670 order.associate_trades = Some(vec![trade.id.clone()]);
5671 trade.size = "99.995".to_string();
5672 trade.price = order.price.clone();
5673 trade.maker_orders[0].matched_amount = dec!(99.995);
5674 trade.maker_orders[0].price = trade.price.parse().unwrap();
5675
5676 let token_instruments = AtomicMap::new();
5677 token_instruments.insert(order.asset_id, instrument.clone());
5678 let fill_tracker = OrderFillTrackerMap::new();
5679 let venue_order_id = VenueOrderId::from(order.id.as_str());
5680 fill_tracker.register(
5681 venue_order_id,
5682 Quantity::from("100"),
5683 OrderSide::Buy,
5684 instrument.id(),
5685 instrument.size_precision(),
5686 instrument.price_precision(),
5687 );
5688 let pending_submits = PendingSubmitTracker::default();
5689 let order_contexts = OrderContextRegistry::default();
5690 register_context(
5691 &order_contexts,
5692 venue_order_id,
5693 instrument.id(),
5694 "O-CONFIRMED-DUST",
5695 );
5696 order_contexts.mark_accepted(venue_order_id);
5697 let mut emitter = test_emitter();
5698 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
5699 emitter.set_sender(sender);
5700 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
5701 settlement.mark_live();
5702 settlement.note_order_submitted(venue_order_id);
5703
5704 let ctx = WsDispatchContext {
5705 signer_type: PolymarketSignerType::Owner,
5706 token_instruments: &token_instruments,
5707 fill_tracker: &fill_tracker,
5708 settlement: &settlement,
5709 pending_submits: &pending_submits,
5710 order_contexts: &order_contexts,
5711 emitter: &emitter,
5712 account_id: AccountId::from("POLY-001"),
5713 clock: nautilus_core::time::get_atomic_clock_realtime(),
5714 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
5715 user_api_key: "00000000-0000-0000-0000-000000000001",
5716 };
5717 let mut state = WsDispatchState::default();
5718
5719 dispatch_user_message(&UserWsMessage::Order(order), &ctx, &mut state);
5720 assert!(receiver.try_recv().is_err());
5721
5722 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
5723
5724 let real_fill = receiver.try_recv().expect("expected confirmed venue fill");
5725 let normalized = receiver
5726 .try_recv()
5727 .expect("expected quantity normalization");
5728
5729 match (real_fill, normalized) {
5730 (
5731 ExecutionEvent::Order(OrderEventAny::Filled(real)),
5732 ExecutionEvent::Order(OrderEventAny::Updated(updated)),
5733 ) => {
5734 assert_eq!(real.last_qty, Quantity::from("99.995"));
5735 assert_eq!(updated.quantity, Quantity::from("99.995"));
5736 assert!(updated.reconciliation);
5737 }
5738 other => panic!("expected fill then quantity update, was {other:?}"),
5739 }
5740 assert!(receiver.try_recv().is_err());
5741 }
5742
5743 #[rstest]
5744 fn test_cancel_reemitted_after_fill_for_canceled_order() {
5745 let cancel_order: PolymarketUserOrder = load("ws_user_order_cancellation.json");
5746 let trade: PolymarketUserTrade = load("ws_user_trade.json");
5747 let instrument = instrument_for_trade(&trade);
5748
5749 let token_instruments = AtomicMap::new();
5750 token_instruments.insert(cancel_order.asset_id, instrument.clone());
5751
5752 let fill_tracker = OrderFillTrackerMap::new();
5753 let venue_order_id = VenueOrderId::from(cancel_order.id.as_str());
5754
5755 fill_tracker.register(
5757 venue_order_id,
5758 Quantity::from("100"),
5759 OrderSide::Buy,
5760 instrument.id(),
5761 instrument.size_precision(),
5762 instrument.price_precision(),
5763 );
5764
5765 let pending_submits = PendingSubmitTracker::default();
5766 let order_contexts = OrderContextRegistry::default();
5767 register_context(&order_contexts, venue_order_id, instrument.id(), "O-CANCEL");
5768 order_contexts.mark_accepted(venue_order_id);
5769 let mut emitter = test_emitter();
5770 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
5771 emitter.set_sender(sender);
5772
5773 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
5774 settlement.mark_live();
5775 settlement.note_order_submitted(venue_order_id);
5776
5777 let ctx = WsDispatchContext {
5778 signer_type: PolymarketSignerType::Owner,
5779 token_instruments: &token_instruments,
5780 fill_tracker: &fill_tracker,
5781 settlement: &settlement,
5782 pending_submits: &pending_submits,
5783 order_contexts: &order_contexts,
5784 emitter: &emitter,
5785 account_id: AccountId::from("POLY-001"),
5786 clock: nautilus_core::time::get_atomic_clock_realtime(),
5787 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
5788 user_api_key: "00000000-0000-0000-0000-000000000001",
5789 };
5790 let mut state = WsDispatchState::default();
5791
5792 dispatch_user_message(&UserWsMessage::Order(cancel_order), &ctx, &mut state);
5794 let cancel_event = receiver.try_recv().expect("Expected canceled event");
5795 match &cancel_event {
5796 ExecutionEvent::Order(OrderEventAny::Canceled(c)) => {
5797 assert_eq!(c.venue_order_id, Some(venue_order_id));
5798 }
5799 other => panic!("Expected canceled event, was {other:?}"),
5800 }
5801
5802 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
5804
5805 let fill_event = receiver.try_recv().expect("Expected filled event");
5807 match &fill_event {
5808 ExecutionEvent::Order(OrderEventAny::Filled(f)) => {
5809 assert_eq!(f.venue_order_id, venue_order_id);
5810 }
5811 other => panic!("Expected filled event, was {other:?}"),
5812 }
5813
5814 let reemitted_cancel = receiver
5815 .try_recv()
5816 .expect("Expected re-emitted canceled event");
5817
5818 match &reemitted_cancel {
5819 ExecutionEvent::Order(OrderEventAny::Canceled(c)) => {
5820 assert_eq!(c.venue_order_id, Some(venue_order_id));
5821 }
5822 other => panic!("Expected canceled event, was {other:?}"),
5823 }
5824 }
5825
5826 #[rstest]
5827 fn test_gtd_expiry_reemitted_after_late_fill() {
5828 let mut cancel_order: PolymarketUserOrder = load("ws_user_order_cancellation.json");
5829 cancel_order.order_type = Some(PolymarketOrderType::GTD);
5830 cancel_order.expiration = Some("1703875265".to_string());
5831 let trade: PolymarketUserTrade = load("ws_user_trade.json");
5832 let instrument = instrument_for_trade(&trade);
5833 let token_instruments = AtomicMap::new();
5834 token_instruments.insert(cancel_order.asset_id, instrument.clone());
5835 let fill_tracker = OrderFillTrackerMap::new();
5836 let venue_order_id = VenueOrderId::from(cancel_order.id.as_str());
5837 fill_tracker.register(
5838 venue_order_id,
5839 Quantity::from("100"),
5840 OrderSide::Buy,
5841 instrument.id(),
5842 instrument.size_precision(),
5843 instrument.price_precision(),
5844 );
5845 let pending_submits = PendingSubmitTracker::default();
5846 let order_contexts = OrderContextRegistry::default();
5847 register_context(
5848 &order_contexts,
5849 venue_order_id,
5850 instrument.id(),
5851 "O-GTD-EXPIRE",
5852 );
5853 order_contexts.mark_accepted(venue_order_id);
5854 let mut emitter = test_emitter();
5855 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
5856 emitter.set_sender(sender);
5857 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
5858 settlement.mark_live();
5859 settlement.note_order_submitted(venue_order_id);
5860
5861 let ctx = WsDispatchContext {
5862 signer_type: PolymarketSignerType::Owner,
5863 token_instruments: &token_instruments,
5864 fill_tracker: &fill_tracker,
5865 settlement: &settlement,
5866 pending_submits: &pending_submits,
5867 order_contexts: &order_contexts,
5868 emitter: &emitter,
5869 account_id: AccountId::from("POLY-001"),
5870 clock: nautilus_core::time::get_atomic_clock_realtime(),
5871 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
5872 user_api_key: "00000000-0000-0000-0000-000000000001",
5873 };
5874
5875 let mut state = WsDispatchState::default();
5876
5877 dispatch_user_message(&UserWsMessage::Order(cancel_order), &ctx, &mut state);
5878
5879 match receiver.try_recv().expect("expected expired event") {
5880 ExecutionEvent::Order(OrderEventAny::Expired(event)) => {
5881 assert_eq!(event.venue_order_id, Some(venue_order_id));
5882 }
5883 other => panic!("expected OrderExpired, was {other:?}"),
5884 }
5885
5886 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
5887
5888 match receiver.try_recv().expect("expected fill") {
5889 ExecutionEvent::Order(OrderEventAny::Filled(event)) => {
5890 assert_eq!(event.venue_order_id, venue_order_id);
5891 }
5892 other => panic!("expected fill, was {other:?}"),
5893 }
5894
5895 match receiver.try_recv().expect("expected re-emitted expiry") {
5896 ExecutionEvent::Order(OrderEventAny::Expired(event)) => {
5897 assert_eq!(event.venue_order_id, Some(venue_order_id));
5898 }
5899 other => panic!("expected re-emitted OrderExpired, was {other:?}"),
5900 }
5901 }
5902
5903 #[rstest]
5904 fn test_modified_old_leg_suppresses_gtd_expiry() {
5905 let mut cancel_order: PolymarketUserOrder = load("ws_user_order_cancellation.json");
5906 cancel_order.order_type = Some(PolymarketOrderType::GTD);
5907 cancel_order.expiration = Some("1703875265".to_string());
5908 let trade: PolymarketUserTrade = load("ws_user_trade.json");
5909 let instrument = instrument_for_trade(&trade);
5910 let token_instruments = AtomicMap::new();
5911 token_instruments.insert(cancel_order.asset_id, instrument.clone());
5912 let fill_tracker = OrderFillTrackerMap::new();
5913 let old_venue_order_id = VenueOrderId::from(cancel_order.id.as_str());
5914 fill_tracker.register(
5915 old_venue_order_id,
5916 Quantity::from("100"),
5917 OrderSide::Buy,
5918 instrument.id(),
5919 instrument.size_precision(),
5920 instrument.price_precision(),
5921 );
5922 let client_order_id = ClientOrderId::from("O-MODIFIED-GTD-LEG");
5923 let pending_submits = PendingSubmitTracker::default();
5924 let order_contexts = OrderContextRegistry::default();
5925 register_context(
5926 &order_contexts,
5927 old_venue_order_id,
5928 instrument.id(),
5929 client_order_id.as_str(),
5930 );
5931 order_contexts.mark_accepted(old_venue_order_id);
5932 let mut emitter = test_emitter();
5933 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
5934 emitter.set_sender(sender);
5935 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
5936 settlement.note_order_submitted(old_venue_order_id);
5937
5938 let ctx = WsDispatchContext {
5939 signer_type: PolymarketSignerType::Owner,
5940 token_instruments: &token_instruments,
5941 fill_tracker: &fill_tracker,
5942 settlement: &settlement,
5943 pending_submits: &pending_submits,
5944 order_contexts: &order_contexts,
5945 emitter: &emitter,
5946 account_id: AccountId::from("POLY-001"),
5947 clock: nautilus_core::time::get_atomic_clock_realtime(),
5948 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
5949 user_api_key: "00000000-0000-0000-0000-000000000001",
5950 };
5951
5952 let mut state = WsDispatchState::default();
5953 assert!(state.begin_modify(client_order_id, old_venue_order_id, instrument.id()));
5954 assert!(state.set_modify_replacement(
5955 client_order_id,
5956 VenueOrderId::from("0xreplacement"),
5957 Quantity::from("100"),
5958 Quantity::from("100"),
5959 Quantity::from("0"),
5960 Price::from("0.5"),
5961 ));
5962 assert!(
5963 state
5964 .claim_modify_replacement(VenueOrderId::from("0xreplacement"))
5965 .is_some()
5966 );
5967
5968 dispatch_user_message(&UserWsMessage::Order(cancel_order), &ctx, &mut state);
5969
5970 assert!(receiver.try_recv().is_err());
5971 }
5972
5973 #[rstest]
5974 fn test_modified_old_leg_suppresses_cancel_but_still_emits_late_fill() {
5975 let cancel_order: PolymarketUserOrder = load("ws_user_order_cancellation.json");
5976 let trade: PolymarketUserTrade = load("ws_user_trade.json");
5977 let instrument = instrument_for_trade(&trade);
5978 let token_instruments = AtomicMap::new();
5979 token_instruments.insert(cancel_order.asset_id, instrument.clone());
5980
5981 let fill_tracker = OrderFillTrackerMap::new();
5982 let old_venue_order_id = VenueOrderId::from(cancel_order.id.as_str());
5983 fill_tracker.register(
5984 old_venue_order_id,
5985 Quantity::from("100"),
5986 OrderSide::Buy,
5987 instrument.id(),
5988 instrument.size_precision(),
5989 instrument.price_precision(),
5990 );
5991
5992 let client_order_id = ClientOrderId::from("O-MODIFIED-OLD-LEG");
5993 let pending_submits = PendingSubmitTracker::default();
5994 let order_contexts = OrderContextRegistry::default();
5995 register_context(
5996 &order_contexts,
5997 old_venue_order_id,
5998 instrument.id(),
5999 client_order_id.as_str(),
6000 );
6001 order_contexts.mark_accepted(old_venue_order_id);
6002 let mut emitter = test_emitter();
6003 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
6004 emitter.set_sender(sender);
6005 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
6006 settlement.note_order_submitted(old_venue_order_id);
6007
6008 let ctx = WsDispatchContext {
6009 signer_type: PolymarketSignerType::Owner,
6010 token_instruments: &token_instruments,
6011 fill_tracker: &fill_tracker,
6012 settlement: &settlement,
6013 pending_submits: &pending_submits,
6014 order_contexts: &order_contexts,
6015 emitter: &emitter,
6016 account_id: AccountId::from("POLY-001"),
6017 clock: nautilus_core::time::get_atomic_clock_realtime(),
6018 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
6019 user_api_key: "00000000-0000-0000-0000-000000000001",
6020 };
6021
6022 let mut state = WsDispatchState::default();
6023 let replacement_venue_order_id = VenueOrderId::from("0xreplacement");
6024 assert!(state.begin_modify(client_order_id, old_venue_order_id, instrument.id()));
6025 assert!(state.set_modify_replacement(
6026 client_order_id,
6027 replacement_venue_order_id,
6028 Quantity::from("100"),
6029 Quantity::from("100"),
6030 Quantity::from("0"),
6031 Price::from("0.5"),
6032 ));
6033 assert!(
6034 state
6035 .claim_modify_replacement(replacement_venue_order_id)
6036 .is_some()
6037 );
6038
6039 dispatch_user_message(&UserWsMessage::Order(cancel_order), &ctx, &mut state);
6040 assert!(receiver.try_recv().is_err());
6041
6042 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
6043
6044 match receiver.try_recv().expect("expected late old-leg fill") {
6045 ExecutionEvent::Order(OrderEventAny::Filled(fill)) => {
6046 assert_eq!(fill.client_order_id, client_order_id);
6047 assert_eq!(fill.venue_order_id, old_venue_order_id);
6048 }
6049 other => panic!("expected late old-leg fill, was {other:?}"),
6050 }
6051
6052 assert!(receiver.try_recv().is_err());
6053 }
6054
6055 #[rstest]
6056 fn test_pending_modify_replacement_ws_activity_emits_updated_without_accepted() {
6057 let mut replacement: PolymarketUserOrder = load("ws_user_order_placement.json");
6058 let instrument = test_instrument();
6059 let old_venue_order_id = VenueOrderId::from("0xold-modify-leg");
6060 let replacement_venue_order_id = VenueOrderId::from("0xreplacement-modify-leg");
6061 replacement.id = replacement_venue_order_id.to_string();
6062
6063 let token_instruments = AtomicMap::new();
6064 token_instruments.insert(replacement.asset_id, instrument.clone());
6065 let fill_tracker = OrderFillTrackerMap::new();
6066 fill_tracker.register(
6067 old_venue_order_id,
6068 Quantity::from("100"),
6069 OrderSide::Buy,
6070 instrument.id(),
6071 instrument.size_precision(),
6072 instrument.price_precision(),
6073 );
6074 let client_order_id = ClientOrderId::from("O-PENDING-MODIFY");
6075 let pending_submits = PendingSubmitTracker::default();
6076 let order_contexts = OrderContextRegistry::default();
6077 register_context(
6078 &order_contexts,
6079 old_venue_order_id,
6080 instrument.id(),
6081 client_order_id.as_str(),
6082 );
6083 order_contexts.mark_accepted(old_venue_order_id);
6084 let mut emitter = test_emitter();
6085 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
6086 emitter.set_sender(sender);
6087 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
6088 settlement.mark_live();
6089
6090 let ctx = WsDispatchContext {
6091 signer_type: PolymarketSignerType::Owner,
6092 token_instruments: &token_instruments,
6093 fill_tracker: &fill_tracker,
6094 settlement: &settlement,
6095 pending_submits: &pending_submits,
6096 order_contexts: &order_contexts,
6097 emitter: &emitter,
6098 account_id: AccountId::from("POLY-001"),
6099 clock: nautilus_core::time::get_atomic_clock_realtime(),
6100 user_address: "0xtest",
6101 user_api_key: "test-key",
6102 };
6103
6104 let mut state = WsDispatchState::default();
6105 assert!(state.begin_modify(client_order_id, old_venue_order_id, instrument.id()));
6106 assert!(state.set_modify_replacement(
6107 client_order_id,
6108 replacement_venue_order_id,
6109 Quantity::from("120"),
6110 Quantity::from("100"),
6111 Quantity::from("20"),
6112 Price::from("0.5"),
6113 ));
6114
6115 let original_context = order_contexts.get(&old_venue_order_id).unwrap();
6116
6117 dispatch_user_message(&UserWsMessage::Order(replacement), &ctx, &mut state);
6118
6119 match receiver.try_recv().expect("expected replacement update") {
6120 ExecutionEvent::Order(OrderEventAny::Updated(updated)) => {
6121 assert_eq!(updated.client_order_id, client_order_id);
6122 assert_eq!(updated.venue_order_id, Some(replacement_venue_order_id));
6123 assert_eq!(updated.quantity, Quantity::from("120"));
6124 assert_eq!(updated.price, Some(Price::from("0.5")));
6125 }
6126 other => panic!("expected replacement update, was {other:?}"),
6127 }
6128
6129 assert_eq!(
6130 order_contexts.venue_order_id(&client_order_id),
6131 Some(replacement_venue_order_id)
6132 );
6133 assert_eq!(
6134 order_contexts.get(&old_venue_order_id),
6135 Some(original_context)
6136 );
6137 assert_eq!(
6138 order_contexts.get(&replacement_venue_order_id),
6139 Some(OrderContext {
6140 quantity: Quantity::from("120"),
6141 price: Some(Price::from("0.5")),
6142 ..original_context
6143 })
6144 );
6145 assert!(receiver.try_recv().is_err());
6146 }
6147
6148 #[rstest]
6149 fn test_modify_replacement_missing_context_consumes_claim_without_publication() {
6150 let instrument_id = InstrumentId::from("TEST.POLYMARKET");
6151 let client_order_id = ClientOrderId::from("O-MISSING-CONTEXT");
6152 let old_id = VenueOrderId::from("V-MISSING-CONTEXT-OLD");
6153 let new_id = VenueOrderId::from("V-MISSING-CONTEXT-NEW");
6154 let mut state = WsDispatchState::default();
6155 assert!(state.begin_modify(client_order_id, old_id, instrument_id));
6156 assert!(state.set_modify_replacement(
6157 client_order_id,
6158 new_id,
6159 Quantity::from("12.34"),
6160 Quantity::from("9.87"),
6161 Quantity::from("2.47"),
6162 Price::from("0.6789"),
6163 ));
6164 let order_contexts = OrderContextRegistry::default();
6165 let fill_tracker = OrderFillTrackerMap::new();
6166 let clock = nautilus_core::time::get_atomic_clock_realtime();
6167 let mut emitter = test_emitter();
6168 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
6169 emitter.set_sender(sender);
6170
6171 let activity = state.promote_modify_replacement(
6172 new_id,
6173 &order_contexts,
6174 &fill_tracker,
6175 &emitter,
6176 clock,
6177 |old_venue_order_id| {
6178 assert_eq!(old_venue_order_id, old_id);
6179 order_contexts
6180 .get(&old_venue_order_id)
6181 .map(|context| (context, emitter.account_id()))
6182 },
6183 || panic!("missing context must stop before resolving event time"),
6184 );
6185
6186 let duplicate = state.promote_modify_replacement(
6187 new_id,
6188 &order_contexts,
6189 &fill_tracker,
6190 &emitter,
6191 clock,
6192 |_| panic!("a consumed claim must stop before resolving context"),
6193 || panic!("a consumed claim must stop before resolving event time"),
6194 );
6195
6196 assert!(activity.is_none());
6197 assert!(duplicate.is_none());
6198 assert!(!state.is_modifying(&client_order_id));
6199 assert!(state.pending_modify_promotion(new_id).is_none());
6200 assert!(state.suppress_modify_cancel(old_id));
6201 assert_eq!(order_contexts.get(&new_id), None);
6202 assert_eq!(order_contexts.venue_order_id(&client_order_id), None);
6203 assert!(!fill_tracker.contains(&new_id));
6204 assert!(receiver.try_recv().is_err());
6205 assert!(order_contexts.mark_accepted(new_id));
6206 }
6207
6208 #[rstest]
6209 fn test_pending_modify_replacement_ws_rejection_emits_once_and_closes_old_leg() {
6210 let mut replacement: PolymarketUserOrder = load("ws_user_order_placement.json");
6211 let instrument = test_instrument();
6212 let old_venue_order_id = VenueOrderId::from("0xold-rejected-modify-leg");
6213 let replacement_venue_order_id = VenueOrderId::from("0xrejected-replacement-modify-leg");
6214 replacement.id = replacement_venue_order_id.to_string();
6215 replacement.status = Some(PolymarketUserOrderStatus::new(
6216 PolymarketOrderStatus::Unmatched,
6217 Some("replacement rejected"),
6218 ));
6219
6220 let token_instruments = AtomicMap::new();
6221 token_instruments.insert(replacement.asset_id, instrument.clone());
6222 let fill_tracker = OrderFillTrackerMap::new();
6223 fill_tracker.register(
6224 old_venue_order_id,
6225 Quantity::from("100"),
6226 OrderSide::Buy,
6227 instrument.id(),
6228 instrument.size_precision(),
6229 instrument.price_precision(),
6230 );
6231 let client_order_id = ClientOrderId::from("O-REJECTED-MODIFY");
6232 let pending_submits = PendingSubmitTracker::default();
6233 let order_contexts = OrderContextRegistry::default();
6234 register_context(
6235 &order_contexts,
6236 old_venue_order_id,
6237 instrument.id(),
6238 client_order_id.as_str(),
6239 );
6240 order_contexts.mark_accepted(old_venue_order_id);
6241 let mut emitter = test_emitter();
6242 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
6243 emitter.set_sender(sender);
6244 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
6245 settlement.mark_live();
6246
6247 let ctx = WsDispatchContext {
6248 signer_type: PolymarketSignerType::Owner,
6249 token_instruments: &token_instruments,
6250 fill_tracker: &fill_tracker,
6251 settlement: &settlement,
6252 pending_submits: &pending_submits,
6253 order_contexts: &order_contexts,
6254 emitter: &emitter,
6255 account_id: AccountId::from("POLY-001"),
6256 clock: nautilus_core::time::get_atomic_clock_realtime(),
6257 user_address: "0xtest",
6258 user_api_key: "test-key",
6259 };
6260
6261 let mut state = WsDispatchState::default();
6262 assert!(state.begin_modify(client_order_id, old_venue_order_id, instrument.id()));
6263 let cancel_ts = UnixNanos::from(123);
6264 assert!(state.confirm_modify_cancel(client_order_id, old_venue_order_id, cancel_ts,));
6265 assert!(state.set_modify_replacement(
6266 client_order_id,
6267 replacement_venue_order_id,
6268 Quantity::from("120"),
6269 Quantity::from("100"),
6270 Quantity::from("20"),
6271 Price::from("0.5"),
6272 ));
6273
6274 dispatch_user_message(&UserWsMessage::Order(replacement), &ctx, &mut state);
6275
6276 match receiver.try_recv().expect("expected modify rejection") {
6277 ExecutionEvent::Order(OrderEventAny::ModifyRejected(rejected)) => {
6278 assert_eq!(rejected.client_order_id, client_order_id);
6279 assert_eq!(rejected.venue_order_id, Some(old_venue_order_id));
6280 assert_eq!(rejected.reason, "replacement rejected");
6281 }
6282 other => panic!("expected modify rejection, was {other:?}"),
6283 }
6284
6285 match receiver.try_recv().expect("expected old-leg cancellation") {
6286 ExecutionEvent::Order(OrderEventAny::Canceled(canceled)) => {
6287 assert_eq!(canceled.client_order_id, client_order_id);
6288 assert_eq!(canceled.venue_order_id, Some(old_venue_order_id));
6289 assert_eq!(canceled.ts_event, cancel_ts);
6290 }
6291 other => panic!("expected old-leg cancellation, was {other:?}"),
6292 }
6293
6294 assert!(
6295 state
6296 .pending_modify_promotion(replacement_venue_order_id)
6297 .is_none()
6298 );
6299 assert!(receiver.try_recv().is_err());
6300 }
6301
6302 #[rstest]
6303 fn test_pending_modify_replacement_fill_promotes_before_fill() {
6304 let trade: PolymarketUserTrade = load("ws_user_trade.json");
6305 let instrument = instrument_for_trade(&trade);
6306 let old_venue_order_id = VenueOrderId::from("0xold-fill-leg");
6307 let replacement_venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
6308 let token_instruments = AtomicMap::new();
6309 token_instruments.insert(trade.asset_id, instrument.clone());
6310 let fill_tracker = OrderFillTrackerMap::new();
6311 fill_tracker.register(
6312 old_venue_order_id,
6313 Quantity::from("100"),
6314 OrderSide::Buy,
6315 instrument.id(),
6316 instrument.size_precision(),
6317 instrument.price_precision(),
6318 );
6319 let client_order_id = ClientOrderId::from("O-PENDING-MODIFY-FILL");
6320 let pending_submits = PendingSubmitTracker::default();
6321 let order_contexts = OrderContextRegistry::default();
6322 register_context(
6323 &order_contexts,
6324 old_venue_order_id,
6325 instrument.id(),
6326 client_order_id.as_str(),
6327 );
6328 order_contexts.mark_accepted(old_venue_order_id);
6329 let mut emitter = test_emitter();
6330 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
6331 emitter.set_sender(sender);
6332 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
6333 settlement.note_order_submitted(replacement_venue_order_id);
6334
6335 let ctx = WsDispatchContext {
6336 signer_type: PolymarketSignerType::Owner,
6337 token_instruments: &token_instruments,
6338 fill_tracker: &fill_tracker,
6339 settlement: &settlement,
6340 pending_submits: &pending_submits,
6341 order_contexts: &order_contexts,
6342 emitter: &emitter,
6343 account_id: AccountId::from("POLY-001"),
6344 clock: nautilus_core::time::get_atomic_clock_realtime(),
6345 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
6346 user_api_key: "00000000-0000-0000-0000-000000000001",
6347 };
6348
6349 let mut state = WsDispatchState::default();
6350 assert!(state.begin_modify(client_order_id, old_venue_order_id, instrument.id()));
6351 assert!(state.set_modify_replacement(
6352 client_order_id,
6353 replacement_venue_order_id,
6354 Quantity::from("120"),
6355 Quantity::from("100"),
6356 Quantity::from("20"),
6357 Price::from("0.5"),
6358 ));
6359 let mut cancellation: PolymarketUserOrder = load("ws_user_order_cancellation.json");
6360 cancellation.id = replacement_venue_order_id.to_string();
6361 let cancellation_report = build_ws_order_status_report(
6362 &cancellation,
6363 cancellation.status.as_ref().unwrap(),
6364 cancellation.order_type.unwrap(),
6365 &instrument,
6366 ctx.account_id,
6367 UnixNanos::from(2_000_000_000),
6368 UnixNanos::from(3_000_000_000),
6369 )
6370 .unwrap();
6371 assert!(
6372 fill_tracker
6373 .accept_or_buffer_report(replacement_venue_order_id, cancellation_report)
6374 .is_none()
6375 );
6376
6377 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
6378
6379 match receiver.try_recv().expect("expected replacement update") {
6380 ExecutionEvent::Order(OrderEventAny::Updated(updated)) => {
6381 assert_eq!(updated.client_order_id, client_order_id);
6382 assert_eq!(updated.venue_order_id, Some(replacement_venue_order_id));
6383 assert_eq!(updated.quantity, Quantity::from("120"));
6384 }
6385 other => panic!("expected replacement update, was {other:?}"),
6386 }
6387
6388 match receiver.try_recv().expect("expected replacement fill") {
6389 ExecutionEvent::Order(OrderEventAny::Filled(fill)) => {
6390 assert_eq!(fill.client_order_id, client_order_id);
6391 assert_eq!(fill.venue_order_id, replacement_venue_order_id);
6392 }
6393 other => panic!("expected replacement fill, was {other:?}"),
6394 }
6395
6396 match receiver.try_recv().expect("expected replacement cancel") {
6397 ExecutionEvent::Order(OrderEventAny::Canceled(cancel)) => {
6398 assert_eq!(cancel.client_order_id, client_order_id);
6399 assert_eq!(cancel.venue_order_id, Some(replacement_venue_order_id));
6400 }
6401 other => panic!("expected replacement cancel, was {other:?}"),
6402 }
6403
6404 assert!(receiver.try_recv().is_err());
6405 }
6406
6407 #[rstest]
6408 fn test_modified_buy_overfill_raises_order_qty_with_prior_legs() {
6409 let mut trade: PolymarketUserTrade = load("ws_user_trade.json");
6410 trade.size = "100.000058".to_string();
6411 trade.maker_orders[0].matched_amount = dec!(100.000058);
6412 let instrument = instrument_for_trade(&trade);
6413 let old_venue_order_id = VenueOrderId::from("0xold-overfill-leg");
6414 let replacement_venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
6415 let token_instruments = AtomicMap::new();
6416 token_instruments.insert(trade.asset_id, instrument.clone());
6417 let fill_tracker = OrderFillTrackerMap::new();
6418 fill_tracker.register(
6419 old_venue_order_id,
6420 Quantity::from("120"),
6421 OrderSide::Buy,
6422 instrument.id(),
6423 instrument.size_precision(),
6424 instrument.price_precision(),
6425 );
6426 let client_order_id = ClientOrderId::from("O-MODIFIED-OVERFILL");
6427 let pending_submits = PendingSubmitTracker::default();
6428 let order_contexts = OrderContextRegistry::default();
6429 register_context(
6430 &order_contexts,
6431 old_venue_order_id,
6432 instrument.id(),
6433 client_order_id.as_str(),
6434 );
6435 order_contexts.mark_accepted(old_venue_order_id);
6436 let mut emitter = test_emitter();
6437 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
6438 emitter.set_sender(sender);
6439 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
6440 settlement.note_order_submitted(replacement_venue_order_id);
6441
6442 let ctx = WsDispatchContext {
6443 signer_type: PolymarketSignerType::Owner,
6444 token_instruments: &token_instruments,
6445 fill_tracker: &fill_tracker,
6446 settlement: &settlement,
6447 pending_submits: &pending_submits,
6448 order_contexts: &order_contexts,
6449 emitter: &emitter,
6450 account_id: AccountId::from("POLY-001"),
6451 clock: nautilus_core::time::get_atomic_clock_realtime(),
6452 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
6453 user_api_key: "00000000-0000-0000-0000-000000000001",
6454 };
6455
6456 let mut state = WsDispatchState::default();
6458 assert!(state.begin_modify(client_order_id, old_venue_order_id, instrument.id()));
6459 assert!(state.set_modify_replacement(
6460 client_order_id,
6461 replacement_venue_order_id,
6462 Quantity::from("120"),
6463 Quantity::from("100"),
6464 Quantity::from("20"),
6465 Price::from("0.5"),
6466 ));
6467
6468 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
6469
6470 let promoted = receiver.try_recv().expect("expected replacement update");
6471 let bumped = receiver.try_recv().expect("expected overfill update");
6472 let filled = receiver.try_recv().expect("expected replacement fill");
6473
6474 match promoted {
6475 ExecutionEvent::Order(OrderEventAny::Updated(updated)) => {
6476 assert_eq!(updated.quantity, Quantity::from("120"));
6477 }
6478 other => panic!("expected replacement update, was {other:?}"),
6479 }
6480
6481 match bumped {
6482 ExecutionEvent::Order(OrderEventAny::Updated(updated)) => {
6483 assert_eq!(updated.client_order_id, client_order_id);
6484 assert_eq!(updated.venue_order_id, Some(replacement_venue_order_id));
6485 assert_eq!(updated.quantity.as_decimal(), dec!(120.000058));
6486 }
6487 other => panic!("expected overfill update, was {other:?}"),
6488 }
6489
6490 match filled {
6491 ExecutionEvent::Order(OrderEventAny::Filled(fill)) => {
6492 assert_eq!(fill.venue_order_id, replacement_venue_order_id);
6493 assert_eq!(fill.last_qty.as_decimal(), dec!(100.000058));
6494 }
6495 other => panic!("expected replacement fill, was {other:?}"),
6496 }
6497
6498 assert!(receiver.try_recv().is_err());
6499 }
6500
6501 #[rstest]
6502 fn test_late_modify_completion_does_not_finish_newer_modify() {
6503 let instrument_id = InstrumentId::from("TEST.POLYMARKET");
6504 let client_order_id = ClientOrderId::from("O-MODIFY-GENERATION");
6505 let old_venue_order_id = VenueOrderId::from("0xmodify-generation-old");
6506 let first_replacement_venue_order_id = VenueOrderId::from("0xmodify-generation-first");
6507 let second_replacement_venue_order_id = VenueOrderId::from("0xmodify-generation-second");
6508 let mut state = WsDispatchState::default();
6509
6510 assert!(state.begin_modify(client_order_id, old_venue_order_id, instrument_id));
6511 assert!(state.set_modify_replacement(
6512 client_order_id,
6513 first_replacement_venue_order_id,
6514 Quantity::from("12"),
6515 Quantity::from("12"),
6516 Quantity::from("0"),
6517 Price::from("0.5"),
6518 ));
6519 assert!(
6520 state
6521 .claim_modify_replacement(first_replacement_venue_order_id)
6522 .is_some()
6523 );
6524 assert!(state.begin_modify(
6525 client_order_id,
6526 first_replacement_venue_order_id,
6527 instrument_id,
6528 ));
6529 assert!(state.set_modify_replacement(
6530 client_order_id,
6531 second_replacement_venue_order_id,
6532 Quantity::from("15"),
6533 Quantity::from("15"),
6534 Quantity::from("0"),
6535 Price::from("0.6"),
6536 ));
6537
6538 assert!(
6539 state
6540 .finish_modify_without_replacement(
6541 client_order_id,
6542 old_venue_order_id,
6543 true,
6544 UnixNanos::from(123),
6545 )
6546 .is_none()
6547 );
6548 let promotion = state
6549 .pending_modify_promotion(second_replacement_venue_order_id)
6550 .expect("newer modification must remain pending");
6551 assert_eq!(promotion.client_order_id, client_order_id);
6552 assert_eq!(
6553 promotion.old_venue_order_id,
6554 first_replacement_venue_order_id
6555 );
6556 assert_eq!(promotion.venue_order_id, second_replacement_venue_order_id);
6557 assert_eq!(promotion.quantity, Quantity::from("15"));
6558 assert_eq!(promotion.leg_quantity, Quantity::from("15"));
6559 assert_eq!(promotion.price, Price::from("0.6"));
6560 }
6561
6562 #[rstest]
6563 fn test_pending_modify_lookup_selects_matching_replacement() {
6564 let instrument_id = InstrumentId::from("TEST.POLYMARKET");
6565 let first_client_order_id = ClientOrderId::from("O-MODIFY-LOOKUP-1");
6566 let second_client_order_id = ClientOrderId::from("O-MODIFY-LOOKUP-2");
6567 let first_old_venue_order_id = VenueOrderId::from("0xmodify-lookup-old-1");
6568 let second_old_venue_order_id = VenueOrderId::from("0xmodify-lookup-old-2");
6569 let first_replacement_venue_order_id = VenueOrderId::from("0xmodify-lookup-new-1");
6570 let second_replacement_venue_order_id = VenueOrderId::from("0xmodify-lookup-new-2");
6571 let mut state = WsDispatchState::default();
6572
6573 assert!(state.begin_modify(
6574 first_client_order_id,
6575 first_old_venue_order_id,
6576 instrument_id,
6577 ));
6578 assert!(state.set_modify_replacement(
6579 first_client_order_id,
6580 first_replacement_venue_order_id,
6581 Quantity::from("11"),
6582 Quantity::from("10"),
6583 Quantity::from("1"),
6584 Price::from("0.4"),
6585 ));
6586 assert!(state.begin_modify(
6587 second_client_order_id,
6588 second_old_venue_order_id,
6589 instrument_id,
6590 ));
6591 assert!(state.set_modify_replacement(
6592 second_client_order_id,
6593 second_replacement_venue_order_id,
6594 Quantity::from("22"),
6595 Quantity::from("20"),
6596 Quantity::from("2"),
6597 Price::from("0.6"),
6598 ));
6599
6600 let second = state
6601 .claim_modify_replacement(second_replacement_venue_order_id)
6602 .expect("second replacement must be selected");
6603 assert_eq!(second.client_order_id, second_client_order_id);
6604 assert_eq!(second.old_venue_order_id, second_old_venue_order_id);
6605 assert_eq!(second.venue_order_id, second_replacement_venue_order_id);
6606 assert_eq!(second.quantity, Quantity::from("22"));
6607 assert_eq!(second.leg_quantity, Quantity::from("20"));
6608 assert_eq!(second.price, Price::from("0.6"));
6609
6610 let first = state
6611 .pending_modify_promotion(first_replacement_venue_order_id)
6612 .expect("first replacement must remain pending");
6613 assert_eq!(first.client_order_id, first_client_order_id);
6614 assert_eq!(first.old_venue_order_id, first_old_venue_order_id);
6615 assert_eq!(first.venue_order_id, first_replacement_venue_order_id);
6616 assert_eq!(first.quantity, Quantity::from("11"));
6617 assert_eq!(first.leg_quantity, Quantity::from("10"));
6618 assert_eq!(first.price, Price::from("0.4"));
6619 }
6620
6621 #[rstest]
6622 fn test_begin_cancels_is_atomic_when_one_order_conflicts() {
6623 let instrument_id = InstrumentId::from("TEST.POLYMARKET");
6624 let available_client_order_id = ClientOrderId::from("O-CANCEL-AVAILABLE");
6625 let conflicting_client_order_id = ClientOrderId::from("O-CANCEL-CONFLICT");
6626 let mut state = WsDispatchState::default();
6627
6628 assert!(state.begin_modify(
6629 conflicting_client_order_id,
6630 VenueOrderId::from("0xmodify-conflict"),
6631 instrument_id,
6632 ));
6633 assert!(!state.begin_cancels(&[
6634 (available_client_order_id, instrument_id),
6635 (conflicting_client_order_id, instrument_id),
6636 ]));
6637 assert!(state.begin_modify(
6638 available_client_order_id,
6639 VenueOrderId::from("0xmodify-available"),
6640 instrument_id,
6641 ));
6642 }
6643
6644 #[rstest]
6645 fn test_begin_available_cancels_skips_existing_cancel() {
6646 let instrument_id = InstrumentId::from("TEST.POLYMARKET");
6647 let pending_client_order_id = ClientOrderId::from("O-CANCEL-PENDING");
6648 let available_client_order_id = ClientOrderId::from("O-CANCEL-AVAILABLE");
6649 let modifying_client_order_id = ClientOrderId::from("O-MODIFY-PENDING");
6650 let unreserved_client_order_id = ClientOrderId::from("O-CANCEL-UNRESERVED");
6651 let mut state = WsDispatchState::default();
6652
6653 assert!(state.begin_cancels(&[(pending_client_order_id, instrument_id)]));
6654 assert_eq!(
6655 state
6656 .begin_available_cancels(&[
6657 (pending_client_order_id, instrument_id),
6658 (available_client_order_id, instrument_id),
6659 ])
6660 .unwrap(),
6661 vec![available_client_order_id],
6662 );
6663 assert!(!state.begin_modify(
6664 pending_client_order_id,
6665 VenueOrderId::from("0xcancel-pending"),
6666 instrument_id,
6667 ));
6668 assert!(!state.begin_modify(
6669 available_client_order_id,
6670 VenueOrderId::from("0xcancel-available"),
6671 instrument_id,
6672 ));
6673
6674 state.finish_cancels(&[pending_client_order_id, available_client_order_id]);
6675 assert!(state.begin_modify(
6676 modifying_client_order_id,
6677 VenueOrderId::from("0xmodify-pending"),
6678 instrument_id,
6679 ));
6680 assert!(
6681 state
6682 .begin_available_cancels(&[
6683 (unreserved_client_order_id, instrument_id),
6684 (modifying_client_order_id, instrument_id),
6685 ])
6686 .is_none()
6687 );
6688 assert!(state.begin_modify(
6689 unreserved_client_order_id,
6690 VenueOrderId::from("0xcancel-unreserved"),
6691 instrument_id,
6692 ));
6693 }
6694
6695 #[rstest]
6696 fn test_cancel_and_modify_are_mutually_exclusive() {
6697 let instrument_id = InstrumentId::from("TEST.POLYMARKET");
6698 let client_order_id = ClientOrderId::from("O-MODIFY-CANCEL-ALL");
6699 let other_client_order_id = ClientOrderId::from("O-MODIFY-MARKET-CANCEL");
6700 let venue_order_id = VenueOrderId::from("0xmodify-cancel-all");
6701 let mut state = WsDispatchState::default();
6702
6703 assert!(state.begin_cancels(&[(client_order_id, instrument_id)]));
6704 assert!(!state.begin_modify(client_order_id, venue_order_id, instrument_id));
6705 assert!(state.begin_market_cancel(instrument_id));
6706 assert!(!state.begin_modify(
6707 other_client_order_id,
6708 VenueOrderId::from("0xmodify-market-cancel"),
6709 instrument_id,
6710 ));
6711 state.finish_market_cancel(instrument_id);
6712 state.finish_cancels(&[client_order_id]);
6713 assert!(state.begin_modify(client_order_id, venue_order_id, instrument_id));
6714 assert!(!state.begin_cancels(&[(client_order_id, instrument_id)]));
6715 assert!(!state.begin_market_cancel(instrument_id));
6716 assert!(state.set_modify_replacement(
6717 client_order_id,
6718 VenueOrderId::from("0xmodify-cancel-all-new"),
6719 Quantity::from("12"),
6720 Quantity::from("12"),
6721 Quantity::from("0"),
6722 Price::from("0.5"),
6723 ));
6724 assert!(!state.begin_cancels(&[(client_order_id, instrument_id)]));
6725 assert!(!state.begin_market_cancel(instrument_id));
6726 assert!(
6727 state
6728 .finish_modify_without_replacement(
6729 client_order_id,
6730 venue_order_id,
6731 false,
6732 UnixNanos::default(),
6733 )
6734 .is_some()
6735 );
6736 assert!(state.begin_market_cancel(instrument_id));
6737 assert!(!state.begin_modify(client_order_id, venue_order_id, instrument_id));
6738 state.finish_market_cancel(instrument_id);
6739 }
6740
6741 #[rstest]
6742 fn test_reset_preserves_modify_recovery_and_stale_leg_safety() {
6743 let instrument_id = InstrumentId::from("TEST.POLYMARKET");
6744 let pending_client_order_id = ClientOrderId::from("O-PENDING-RESET");
6745 let pending_old_venue_order_id = VenueOrderId::from("0xpending-old-reset");
6746 let pending_new_venue_order_id = VenueOrderId::from("0xpending-new-reset");
6747 let replaced_client_order_id = ClientOrderId::from("O-REPLACED-RESET");
6748 let replaced_old_venue_order_id = VenueOrderId::from("0xreplaced-old-reset");
6749 let replaced_new_venue_order_id = VenueOrderId::from("0xreplaced-new-reset");
6750 let closed_client_order_id = ClientOrderId::from("O-CLOSED-RESET");
6751 let closed_venue_order_id = VenueOrderId::from("0xclosed-reset");
6752 let cancel_client_order_id = ClientOrderId::from("O-CANCEL-RESET");
6753 let trade_id = TradeId::from("T-RESET");
6754 let mut state = WsDispatchState::default();
6755
6756 assert!(state.begin_modify(
6757 pending_client_order_id,
6758 pending_old_venue_order_id,
6759 instrument_id,
6760 ));
6761 assert!(state.set_modify_replacement(
6762 pending_client_order_id,
6763 pending_new_venue_order_id,
6764 Quantity::from("12"),
6765 Quantity::from("10"),
6766 Quantity::from("2"),
6767 Price::from("0.5"),
6768 ));
6769 assert!(state.begin_modify(
6770 replaced_client_order_id,
6771 replaced_old_venue_order_id,
6772 instrument_id,
6773 ));
6774 assert!(state.set_modify_replacement(
6775 replaced_client_order_id,
6776 replaced_new_venue_order_id,
6777 Quantity::from("12"),
6778 Quantity::from("10"),
6779 Quantity::from("2"),
6780 Price::from("0.5"),
6781 ));
6782 assert!(
6783 state
6784 .claim_modify_replacement(replaced_new_venue_order_id)
6785 .is_some()
6786 );
6787 assert!(state.begin_modify(closed_client_order_id, closed_venue_order_id, instrument_id,));
6788 assert!(
6789 state
6790 .finish_modify_without_replacement(
6791 closed_client_order_id,
6792 closed_venue_order_id,
6793 true,
6794 UnixNanos::from(1),
6795 )
6796 .is_some()
6797 );
6798 state.record_reconciled_fill(trade_id, pending_old_venue_order_id);
6799 assert!(state.begin_cancels(&[(cancel_client_order_id, instrument_id)]));
6800
6801 state.reset_session();
6802
6803 assert_eq!(
6804 state
6805 .pending_modify_promotion(pending_new_venue_order_id)
6806 .unwrap()
6807 .client_order_id,
6808 pending_client_order_id,
6809 );
6810 assert!(state.suppress_modify_cancel(replaced_old_venue_order_id));
6811 assert!(state.suppress_modify_cancel(closed_venue_order_id));
6812 assert!(state.suppress_modify_cancel_reemit(pending_old_venue_order_id));
6813 assert!(state.suppress_modify_cancel_reemit(replaced_old_venue_order_id));
6814 assert!(!state.suppress_modify_cancel_reemit(closed_venue_order_id));
6815 assert!(
6816 state
6817 .reconciled_fills
6818 .contains(&(trade_id, pending_old_venue_order_id))
6819 );
6820 assert!(state.begin_cancels(&[(cancel_client_order_id, instrument_id)]));
6821 }
6822
6823 #[rstest]
6824 fn test_reconciled_fill_is_not_reapplied_from_websocket() {
6825 let trade: PolymarketUserTrade = load("ws_user_trade.json");
6826 let instrument = instrument_for_trade(&trade);
6827 let venue_order_id = VenueOrderId::from(trade.taker_order_id.as_str());
6828 let token_instruments = AtomicMap::new();
6829 token_instruments.insert(trade.asset_id, instrument.clone());
6830 let fill_tracker = OrderFillTrackerMap::new();
6831 fill_tracker.restore_order(
6832 venue_order_id,
6833 Quantity::from("100"),
6834 Quantity::from("0"),
6835 Quantity::from("0"),
6836 Quantity::from("25"),
6837 OrderSide::Buy,
6838 );
6839 let pending_submits = PendingSubmitTracker::default();
6840 let order_contexts = OrderContextRegistry::default();
6841 register_context(
6842 &order_contexts,
6843 venue_order_id,
6844 instrument.id(),
6845 "O-RECONCILED-FILL",
6846 );
6847 let mut emitter = test_emitter();
6848 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
6849 emitter.set_sender(sender);
6850 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
6851 settlement.mark_live();
6852 settlement.note_order_submitted(venue_order_id);
6853
6854 let ctx = WsDispatchContext {
6855 signer_type: PolymarketSignerType::Owner,
6856 token_instruments: &token_instruments,
6857 fill_tracker: &fill_tracker,
6858 settlement: &settlement,
6859 pending_submits: &pending_submits,
6860 order_contexts: &order_contexts,
6861 emitter: &emitter,
6862 account_id: AccountId::from("POLY-001"),
6863 clock: nautilus_core::time::get_atomic_clock_realtime(),
6864 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
6865 user_api_key: "00000000-0000-0000-0000-000000000001",
6866 };
6867
6868 let mut state = WsDispatchState::default();
6869 state.record_reconciled_fill(TradeId::from(trade.id.as_str()), venue_order_id);
6870
6871 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
6872
6873 assert_eq!(
6874 fill_tracker.get_cumulative_filled(&venue_order_id),
6875 Some(Quantity::from("25")),
6876 );
6877 assert!(receiver.try_recv().is_err());
6878 assert!(settlement.ensure_resolved(None, "mass status").is_ok());
6880 }
6881
6882 #[rstest]
6883 fn test_cancel_not_reemitted_when_fill_completes_order() {
6884 let cancel_order: PolymarketUserOrder = load("ws_user_order_cancellation.json");
6885 let trade: PolymarketUserTrade = load("ws_user_trade.json");
6886 let instrument = instrument_for_trade(&trade);
6887
6888 let token_instruments = AtomicMap::new();
6889 token_instruments.insert(cancel_order.asset_id, instrument.clone());
6890
6891 let fill_tracker = OrderFillTrackerMap::new();
6892 let venue_order_id = VenueOrderId::from(cancel_order.id.as_str());
6893
6894 fill_tracker.register(
6896 venue_order_id,
6897 Quantity::from("25"),
6898 OrderSide::Buy,
6899 instrument.id(),
6900 instrument.size_precision(),
6901 instrument.price_precision(),
6902 );
6903
6904 let pending_submits = PendingSubmitTracker::default();
6905 let order_contexts = OrderContextRegistry::default();
6906 register_context(
6907 &order_contexts,
6908 venue_order_id,
6909 instrument.id(),
6910 "O-CANCEL-FULL",
6911 );
6912 order_contexts.mark_accepted(venue_order_id);
6913 let mut emitter = test_emitter();
6914 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
6915 emitter.set_sender(sender);
6916
6917 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
6918 settlement.mark_live();
6919 settlement.note_order_submitted(venue_order_id);
6920
6921 let ctx = WsDispatchContext {
6922 signer_type: PolymarketSignerType::Owner,
6923 token_instruments: &token_instruments,
6924 fill_tracker: &fill_tracker,
6925 settlement: &settlement,
6926 pending_submits: &pending_submits,
6927 order_contexts: &order_contexts,
6928 emitter: &emitter,
6929 account_id: AccountId::from("POLY-001"),
6930 clock: nautilus_core::time::get_atomic_clock_realtime(),
6931 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
6932 user_api_key: "00000000-0000-0000-0000-000000000001",
6933 };
6934 let mut state = WsDispatchState::default();
6935
6936 dispatch_user_message(&UserWsMessage::Order(cancel_order), &ctx, &mut state);
6938 let _cancel = receiver.try_recv().expect("Expected canceled event");
6939
6940 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
6941 let _fill = receiver.try_recv().expect("Expected filled event");
6942
6943 assert!(
6945 receiver.try_recv().is_err(),
6946 "Should not re-emit cancel when fill completes the order"
6947 );
6948 }
6949
6950 #[rstest]
6951 fn test_cancel_saved_before_acceptance_and_retained_for_modify_reset() {
6952 let cancel_order: PolymarketUserOrder = load("ws_user_order_cancellation.json");
6953 let instrument = test_instrument();
6954 let instrument_id = instrument.id();
6955
6956 let token_instruments = AtomicMap::new();
6957 token_instruments.insert(cancel_order.asset_id, instrument);
6958
6959 let fill_tracker = OrderFillTrackerMap::new();
6961 let venue_order_id = VenueOrderId::from(cancel_order.id.as_str());
6962
6963 let pending_submits = PendingSubmitTracker::default();
6964 let order_contexts = OrderContextRegistry::default();
6965 let emitter = test_emitter();
6966
6967 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
6968 settlement.mark_live();
6969 settlement.note_order_submitted(venue_order_id);
6970
6971 let ctx = WsDispatchContext {
6972 signer_type: PolymarketSignerType::Owner,
6973 token_instruments: &token_instruments,
6974 fill_tracker: &fill_tracker,
6975 settlement: &settlement,
6976 pending_submits: &pending_submits,
6977 order_contexts: &order_contexts,
6978 emitter: &emitter,
6979 account_id: AccountId::from("POLY-001"),
6980 clock: nautilus_core::time::get_atomic_clock_realtime(),
6981 user_address: "0xtest",
6982 user_api_key: "test-key",
6983 };
6984 let mut state = WsDispatchState::default();
6985
6986 dispatch_user_message(&UserWsMessage::Order(cancel_order), &ctx, &mut state);
6988
6989 assert!(fill_tracker.has_pending_report(&venue_order_id));
6991 assert!(state.terminal_cancel_reports.get(&venue_order_id).is_some());
6992
6993 let client_order_id = ClientOrderId::from("O-CANCEL-RESET");
6994 assert!(state.begin_modify(client_order_id, venue_order_id, instrument_id));
6995 state.reset_session();
6996 assert!(
6997 state
6998 .finish_modify_without_replacement(
6999 client_order_id,
7000 venue_order_id,
7001 false,
7002 UnixNanos::default(),
7003 )
7004 .unwrap()
7005 .1
7006 .is_some()
7007 );
7008 }
7009
7010 #[rstest]
7013 #[case(PolymarketOrderStatus::Canceled, "Canceled", OrderStatus::Canceled)]
7014 #[case(
7015 PolymarketOrderStatus::CanceledMarketResolved,
7016 "Expired",
7017 OrderStatus::Expired
7018 )]
7019 fn test_buffered_fill_emitted_before_terminal_status(
7020 #[case] status: PolymarketOrderStatus,
7021 #[case] expected_terminal: &str,
7022 #[case] expected_order_status: OrderStatus,
7023 #[values(false, true)] context_before_update: bool,
7024 ) {
7025 let mut terminal_order: PolymarketUserOrder = load("ws_user_order_cancellation.json");
7026 terminal_order.status = Some(status.into());
7027 let trade: PolymarketUserTrade = load("ws_user_trade.json");
7028 let instrument = instrument_for_trade(&trade);
7029
7030 let token_instruments = AtomicMap::new();
7031 token_instruments.insert(terminal_order.asset_id, instrument.clone());
7032
7033 let fill_tracker = OrderFillTrackerMap::new();
7035 let venue_order_id = VenueOrderId::from(terminal_order.id.as_str());
7036 let client_order_id = ClientOrderId::from("O-BUFFERED");
7037
7038 let pending_submits = PendingSubmitTracker::default();
7039 pending_submits.insert(venue_order_id, client_order_id);
7040 let order_contexts = OrderContextRegistry::default();
7041
7042 if context_before_update {
7043 register_context(
7044 &order_contexts,
7045 venue_order_id,
7046 instrument.id(),
7047 client_order_id.as_str(),
7048 );
7049 }
7050
7051 let mut emitter = test_emitter();
7052 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
7053 emitter.set_sender(sender);
7054
7055 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
7056 settlement.mark_live();
7057 settlement.note_order_submitted(venue_order_id);
7058
7059 let ctx = WsDispatchContext {
7060 signer_type: PolymarketSignerType::Owner,
7061 token_instruments: &token_instruments,
7062 fill_tracker: &fill_tracker,
7063 settlement: &settlement,
7064 pending_submits: &pending_submits,
7065 order_contexts: &order_contexts,
7066 emitter: &emitter,
7067 account_id: AccountId::from("POLY-001"),
7068 clock: nautilus_core::time::get_atomic_clock_realtime(),
7069 user_address: "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
7070 user_api_key: "00000000-0000-0000-0000-000000000001",
7071 };
7072 let mut state = WsDispatchState::default();
7073
7074 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
7076 assert!(
7077 receiver.try_recv().is_err(),
7078 "a buffered fill must emit no event before the order is registered",
7079 );
7080
7081 if !context_before_update {
7082 dispatch_user_message(
7083 &UserWsMessage::Order(terminal_order.clone()),
7084 &ctx,
7085 &mut state,
7086 );
7087 assert!(receiver.try_recv().is_err());
7088 assert!(!fill_tracker.contains(&venue_order_id));
7089 register_context(
7090 &order_contexts,
7091 venue_order_id,
7092 instrument.id(),
7093 client_order_id.as_str(),
7094 );
7095 }
7096
7097 dispatch_user_message(&UserWsMessage::Order(terminal_order), &ctx, &mut state);
7099
7100 let mut emitted = Vec::new();
7101
7102 while let Ok(event) = receiver.try_recv() {
7103 match event {
7104 ExecutionEvent::Order(order_event) => emitted.push(order_event),
7105 other => panic!("expected only order events, was {other:?}"),
7106 }
7107 }
7108
7109 assert_eq!(emitted.len(), 3, "emitted sequence was {emitted:?}");
7110 match &emitted[0] {
7111 OrderEventAny::Accepted(accepted) => {
7112 assert_eq!(accepted.client_order_id, client_order_id);
7113 assert_eq!(accepted.venue_order_id, venue_order_id);
7114 }
7115 other => panic!("expected accepted event first, was {other:?}"),
7116 }
7117
7118 match &emitted[1] {
7119 OrderEventAny::Filled(filled) => {
7120 assert_eq!(filled.client_order_id, client_order_id);
7121 assert_eq!(filled.venue_order_id, venue_order_id);
7122 assert_eq!(filled.last_qty.as_decimal(), dec!(25));
7123 }
7124 other => panic!("expected filled event before the terminal status, was {other:?}"),
7125 }
7126
7127 let terminal = match &emitted[2] {
7128 OrderEventAny::Canceled(canceled) => {
7129 assert_eq!(canceled.client_order_id, client_order_id);
7130 assert_eq!(canceled.venue_order_id, Some(venue_order_id));
7131 "Canceled"
7132 }
7133 OrderEventAny::Expired(expired) => {
7134 assert_eq!(expired.client_order_id, client_order_id);
7135 assert_eq!(expired.venue_order_id, Some(venue_order_id));
7136 "Expired"
7137 }
7138 other => panic!("expected a terminal order event last, was {other:?}"),
7139 };
7140 assert_eq!(terminal, expected_terminal);
7141
7142 let mut order = OrderTestBuilder::new(OrderType::Limit)
7144 .instrument_id(instrument.id())
7145 .client_order_id(client_order_id)
7146 .strategy_id(StrategyId::from("S-001"))
7147 .side(OrderSide::Buy)
7148 .price(Price::from("0.5"))
7149 .quantity(Quantity::from("100"))
7150 .build();
7151
7152 for event in emitted {
7153 order.apply(event).expect("emitted sequence must be valid");
7154 }
7155
7156 assert_eq!(order.status(), expected_order_status);
7157 assert_eq!(order.filled_qty().as_decimal(), dec!(25));
7158 }
7159
7160 #[rstest]
7172 fn test_issue_3797_interleaved_cancel_fill_sequence() {
7173 use crate::common::{
7174 enums::{
7175 PolymarketEventType, PolymarketLiquiditySide, PolymarketOrderSide,
7176 PolymarketOrderStatus, PolymarketOrderType, PolymarketOutcome,
7177 PolymarketTradeStatus,
7178 },
7179 models::PolymarketMakerOrder,
7180 };
7181
7182 let instrument = bind_instrument(test_instrument(), "0x4134", PolymarketOutcome::yes());
7183 let asset_id = instrument.id().symbol.inner();
7184
7185 let order_id =
7186 "0xe743f6c823ecdfa9ddaaf08673b2441d15a38d89e14dcb25b3b70c284be4f6ad".to_string();
7187 let venue_order_id = VenueOrderId::from(order_id.as_str());
7188
7189 let token_instruments = AtomicMap::new();
7190 token_instruments.insert(asset_id, instrument.clone());
7191
7192 let fill_tracker = OrderFillTrackerMap::new();
7193 fill_tracker.register(
7194 venue_order_id,
7195 Quantity::from("20"),
7196 OrderSide::Buy,
7197 instrument.id(),
7198 instrument.size_precision(),
7199 instrument.price_precision(),
7200 );
7201
7202 let pending_submits = PendingSubmitTracker::default();
7203 let order_contexts = OrderContextRegistry::default();
7204 register_context(&order_contexts, venue_order_id, instrument.id(), "O-3797");
7205 order_contexts.mark_accepted(venue_order_id);
7206 let mut emitter = test_emitter();
7207 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
7208 emitter.set_sender(sender);
7209
7210 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
7211 settlement.mark_live();
7212 settlement.note_order_submitted(venue_order_id);
7213
7214 let ctx = WsDispatchContext {
7215 signer_type: PolymarketSignerType::Owner,
7216 token_instruments: &token_instruments,
7217 fill_tracker: &fill_tracker,
7218 settlement: &settlement,
7219 pending_submits: &pending_submits,
7220 order_contexts: &order_contexts,
7221 emitter: &emitter,
7222 account_id: AccountId::from("POLY-001"),
7223 clock: nautilus_core::time::get_atomic_clock_realtime(),
7224 user_address: "0xabc",
7225 user_api_key: "xxx",
7226 };
7227 let mut state = WsDispatchState::default();
7228
7229 let make_order =
7230 |size_matched: &str, ts: &str, event_type: PolymarketEventType| PolymarketUserOrder {
7231 asset_id,
7232 associate_trades: None,
7233 created_at: Some("1775074735".to_string()),
7234 expiration: Some("0".to_string()),
7235 id: order_id.clone(),
7236 maker_address: Some(Ustr::from("0xabc")),
7237 market: Ustr::from("0x4134"),
7238 order_owner: Some(Ustr::from("xxx")),
7239 order_type: Some(PolymarketOrderType::GTC),
7240 original_size: "20".to_string(),
7241 outcome: Some(PolymarketOutcome::yes()),
7242 owner: Ustr::from("xxx"),
7243 price: "0.18".to_string(),
7244 side: PolymarketOrderSide::Buy,
7245 size_matched: size_matched.to_string(),
7246 status: Some(PolymarketOrderStatus::Canceled.into()),
7247 timestamp: ts.to_string(),
7248 event_type,
7249 };
7250
7251 let make_trade = |trade_id: &str, matched_amount: f64, ts: &str| PolymarketUserTrade {
7252 asset_id,
7253 bucket_index: 0,
7254 fee_rate_bps: "1000".to_string(),
7255 id: trade_id.to_string(),
7256 last_update: "1775074738".to_string(),
7257 maker_address: Ustr::from("0xother"),
7258 maker_orders: vec![PolymarketMakerOrder {
7259 asset_id,
7260 maker_address: "0xabc".to_string(),
7261 matched_amount: Decimal::from_str_exact(&matched_amount.to_string())
7262 .unwrap_or(Decimal::ZERO),
7263 order_id: order_id.clone(),
7264 outcome: PolymarketOutcome::yes(),
7265 owner: "xxx".to_string(),
7266 price: Decimal::from_str_exact("0.18").unwrap_or(Decimal::ZERO),
7267 side: None,
7268 }],
7269 market: Ustr::from("0x4134"),
7270 match_time: "1775074735".to_string(),
7271 outcome: PolymarketOutcome::yes(),
7272 owner: Ustr::from("other-owner"),
7273 price: "0.82".to_string(),
7274 side: PolymarketOrderSide::Buy,
7275 size: "1.219511".to_string(),
7276 status: PolymarketTradeStatus::Confirmed,
7277 taker_order_id: "0xtaker01".to_string(),
7278 timestamp: ts.to_string(),
7279 trade_owner: Ustr::from("other-owner"),
7280 transaction_hash: None,
7281 trader_side: PolymarketLiquiditySide::Maker,
7282 event_type: PolymarketEventType::Trade,
7283 };
7284
7285 let msg_a = make_order("0", "1775074738031", PolymarketEventType::Cancellation);
7287 dispatch_user_message(&UserWsMessage::Order(msg_a), &ctx, &mut state);
7288
7289 let evt = receiver.try_recv().expect("(A) canceled event");
7290 match &evt {
7291 ExecutionEvent::Order(OrderEventAny::Canceled(c)) => {
7292 assert_eq!(c.venue_order_id, Some(venue_order_id));
7293 }
7294 other => panic!("(A) expected canceled event, was {other:?}"),
7295 }
7296
7297 let msg_b = make_trade("trade-b", 1.219511, "1775074738032");
7299 dispatch_user_message(&UserWsMessage::Trade(msg_b), &ctx, &mut state);
7300
7301 let evt = receiver.try_recv().expect("(B) filled event");
7302 match &evt {
7303 ExecutionEvent::Order(OrderEventAny::Filled(f)) => {
7304 assert_eq!(f.venue_order_id, venue_order_id);
7305 }
7306 other => panic!("(B) expected filled event, was {other:?}"),
7307 }
7308 let evt = receiver.try_recv().expect("(B) re-emitted cancel");
7310 match &evt {
7311 ExecutionEvent::Order(OrderEventAny::Canceled(c)) => {
7312 assert_eq!(c.venue_order_id, Some(venue_order_id));
7313 }
7314 other => panic!("(B) expected re-emitted cancel, was {other:?}"),
7315 }
7316
7317 let msg_c = make_order("1.219511", "1775074738034", PolymarketEventType::Update);
7319 dispatch_user_message(&UserWsMessage::Order(msg_c), &ctx, &mut state);
7320
7321 let evt = receiver.try_recv().expect("(C) canceled event");
7322 match &evt {
7323 ExecutionEvent::Order(OrderEventAny::Canceled(c)) => {
7324 assert_eq!(c.venue_order_id, Some(venue_order_id));
7325 }
7326 other => panic!("(C) expected canceled event, was {other:?}"),
7327 }
7328
7329 let msg_d = make_order("2.560972", "1775074738038", PolymarketEventType::Update);
7331 dispatch_user_message(&UserWsMessage::Order(msg_d), &ctx, &mut state);
7332
7333 let evt = receiver.try_recv().expect("(D) canceled event");
7334 match &evt {
7335 ExecutionEvent::Order(OrderEventAny::Canceled(c)) => {
7336 assert_eq!(c.venue_order_id, Some(venue_order_id));
7337 }
7338 other => panic!("(D) expected canceled event, was {other:?}"),
7339 }
7340
7341 let msg_e = make_trade("trade-e", 1.341461, "1775074738036");
7343 dispatch_user_message(&UserWsMessage::Trade(msg_e), &ctx, &mut state);
7344
7345 let evt = receiver.try_recv().expect("(E) filled event");
7346 match &evt {
7347 ExecutionEvent::Order(OrderEventAny::Filled(f)) => {
7348 assert_eq!(f.venue_order_id, venue_order_id);
7349 }
7350 other => panic!("(E) expected filled event, was {other:?}"),
7351 }
7352
7353 let evt = receiver.try_recv().expect("(E) re-emitted cancel");
7355 match &evt {
7356 ExecutionEvent::Order(OrderEventAny::Canceled(c)) => {
7357 assert_eq!(c.venue_order_id, Some(venue_order_id));
7358 }
7359 other => panic!("(E) expected re-emitted cancel, was {other:?}"),
7360 }
7361
7362 assert!(
7364 receiver.try_recv().is_err(),
7365 "No further events expected after the sequence"
7366 );
7367 }
7368
7369 #[rstest]
7370 fn test_dispatch_taker_fill_bumps_qty_for_dust_overfill() {
7371 use crate::common::enums::{
7375 PolymarketEventType, PolymarketOrderSide, PolymarketOutcome, PolymarketTradeStatus,
7376 };
7377
7378 let instrument = bind_instrument(test_instrument(), "0xmarket", PolymarketOutcome::yes());
7379 let asset_id = instrument.id().symbol.inner();
7380 let token_instruments = AtomicMap::new();
7381 token_instruments.insert(asset_id, instrument.clone());
7382
7383 let fill_tracker = OrderFillTrackerMap::new();
7384 let venue_order_id = VenueOrderId::from("0xtaker-overfill");
7385 let submitted =
7386 Quantity::from_decimal_dp(dec!(7.5757), instrument.size_precision()).unwrap();
7387 fill_tracker.register(
7388 venue_order_id,
7389 submitted,
7390 OrderSide::Buy,
7391 instrument.id(),
7392 instrument.size_precision(),
7393 instrument.price_precision(),
7394 );
7395
7396 let pending_submits = PendingSubmitTracker::default();
7397 let order_contexts = OrderContextRegistry::default();
7398 register_context(
7399 &order_contexts,
7400 venue_order_id,
7401 instrument.id(),
7402 "O-OVERFILL",
7403 );
7404 order_contexts.mark_accepted(venue_order_id);
7405 let mut emitter = test_emitter();
7406 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
7407 emitter.set_sender(sender);
7408
7409 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
7410 settlement.mark_live();
7411 settlement.note_order_submitted(venue_order_id);
7412
7413 let ctx = WsDispatchContext {
7414 signer_type: PolymarketSignerType::Owner,
7415 token_instruments: &token_instruments,
7416 fill_tracker: &fill_tracker,
7417 settlement: &settlement,
7418 pending_submits: &pending_submits,
7419 order_contexts: &order_contexts,
7420 emitter: &emitter,
7421 account_id: AccountId::from("POLY-001"),
7422 clock: nautilus_core::time::get_atomic_clock_realtime(),
7423 user_address: "0xtest",
7424 user_api_key: "00000000-0000-0000-0000-000000000001",
7425 };
7426 let mut state = WsDispatchState::default();
7427
7428 let trade = PolymarketUserTrade {
7429 asset_id,
7430 bucket_index: 0,
7431 fee_rate_bps: "0".to_string(),
7432 id: "trade-overfill".to_string(),
7433 last_update: "1700000001".to_string(),
7434 maker_address: Ustr::from("0xmaker"),
7435 maker_orders: vec![],
7436 market: Ustr::from("0xmarket"),
7437 match_time: "1700000000".to_string(),
7438 outcome: PolymarketOutcome::yes(),
7439 owner: Ustr::from("00000000-0000-0000-0000-000000000001"),
7440 price: "0.66".to_string(),
7441 side: PolymarketOrderSide::Buy,
7442 size: "7.575758".to_string(),
7443 status: PolymarketTradeStatus::Confirmed,
7444 taker_order_id: venue_order_id.as_str().to_string(),
7445 timestamp: "1700000000000".to_string(),
7446 trade_owner: Ustr::from("00000000-0000-0000-0000-000000000001"),
7447 transaction_hash: None,
7448 trader_side: PolymarketLiquiditySide::Taker,
7449 event_type: PolymarketEventType::Trade,
7450 };
7451
7452 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
7453
7454 let venue_qty =
7455 Quantity::from_decimal_dp(dec!(7.575758), instrument.size_precision()).unwrap();
7456 let cumulative = fill_tracker.get_cumulative_filled(&venue_order_id);
7457 let updated = receiver.try_recv().expect("expected an updated event");
7458 let filled = receiver.try_recv().expect("expected a filled event");
7459
7460 assert_eq!(cumulative, Some(venue_qty));
7461 assert_eq!(fill_tracker.submitted_qty(&venue_order_id), Some(venue_qty));
7462
7463 match updated {
7464 ExecutionEvent::Order(OrderEventAny::Updated(updated)) => {
7465 assert_eq!(updated.quantity, venue_qty);
7466 assert_eq!(updated.venue_order_id, Some(venue_order_id));
7467 }
7468 other => panic!("expected updated event, was {other:?}"),
7469 }
7470
7471 match filled {
7472 ExecutionEvent::Order(OrderEventAny::Filled(filled)) => {
7473 assert_eq!(filled.last_qty, venue_qty);
7474 assert_eq!(filled.venue_order_id, venue_order_id);
7475 }
7476 other => panic!("expected filled event, was {other:?}"),
7477 }
7478
7479 assert!(receiver.try_recv().is_err());
7480 }
7481
7482 #[rstest]
7483 #[case(
7484 TimeInForce::Ioc,
7485 OrderType::Market,
7486 OrderSide::Buy,
7487 "5.202910",
7488 "5.202897",
7489 false,
7490 true
7491 )]
7492 #[case(
7493 TimeInForce::Fok,
7494 OrderType::Limit,
7495 OrderSide::Buy,
7496 "5.202910",
7497 "5.202897",
7498 true,
7499 false
7500 )]
7501 #[case(
7502 TimeInForce::Ioc,
7503 OrderType::Limit,
7504 OrderSide::Buy,
7505 "30",
7506 "20",
7507 false,
7508 true
7509 )]
7510 #[case(
7511 TimeInForce::Ioc,
7512 OrderType::Market,
7513 OrderSide::Sell,
7514 "5.202910",
7515 "5.202897",
7516 false,
7517 true
7518 )]
7519 #[case(
7520 TimeInForce::Gtc,
7521 OrderType::Limit,
7522 OrderSide::Buy,
7523 "5.202910",
7524 "5.202897",
7525 false,
7526 false
7527 )]
7528 fn test_taker_terminal_status_on_trade_confirm(
7529 #[case] time_in_force: TimeInForce,
7530 #[case] order_type: OrderType,
7531 #[case] order_side: OrderSide,
7532 #[case] submitted_qty: &str,
7533 #[case] fill_qty: &str,
7534 #[case] expect_normalization: bool,
7535 #[case] expect_cancel: bool,
7536 ) {
7537 use crate::common::enums::{
7541 PolymarketEventType, PolymarketOrderSide, PolymarketOutcome, PolymarketTradeStatus,
7542 };
7543
7544 let instrument = bind_instrument(test_instrument(), "0xmarket", PolymarketOutcome::yes());
7545 let asset_id = instrument.id().symbol.inner();
7546 let token_instruments = AtomicMap::new();
7547 token_instruments.insert(asset_id, instrument.clone());
7548
7549 let fill_tracker = OrderFillTrackerMap::new();
7550 let venue_order_id = VenueOrderId::from("0xtaker-one-shot-dust");
7551 let submitted = Quantity::from_decimal_dp(
7552 Decimal::from_str_exact(submitted_qty).unwrap(),
7553 instrument.size_precision(),
7554 )
7555 .unwrap();
7556 fill_tracker.register(
7557 venue_order_id,
7558 submitted,
7559 order_side,
7560 instrument.id(),
7561 instrument.size_precision(),
7562 instrument.price_precision(),
7563 );
7564
7565 let pending_submits = PendingSubmitTracker::default();
7566 let order_contexts = OrderContextRegistry::default();
7567 order_contexts.register_context(
7568 venue_order_id,
7569 OrderContext {
7570 identity: OrderIdentity {
7571 client_order_id: ClientOrderId::from("O-ONE-SHOT"),
7572 strategy_id: StrategyId::from("S-001"),
7573 instrument_id: instrument.id(),
7574 order_side,
7575 order_type,
7576 },
7577 quantity: submitted,
7578 price: Some(Price::from("0.50")),
7579 trigger_price: None,
7580 trigger_type: None,
7581 time_in_force,
7582 is_post_only: false,
7583 is_reduce_only: false,
7584 is_quote_quantity: false,
7585 },
7586 );
7587 order_contexts.mark_accepted(venue_order_id);
7588 let mut emitter = test_emitter();
7589 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
7590 emitter.set_sender(sender);
7591
7592 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
7593 settlement.mark_live();
7594 settlement.note_order_submitted(venue_order_id);
7595
7596 let ctx = WsDispatchContext {
7597 signer_type: PolymarketSignerType::Owner,
7598 token_instruments: &token_instruments,
7599 fill_tracker: &fill_tracker,
7600 settlement: &settlement,
7601 pending_submits: &pending_submits,
7602 order_contexts: &order_contexts,
7603 emitter: &emitter,
7604 account_id: AccountId::from("POLY-001"),
7605 clock: nautilus_core::time::get_atomic_clock_realtime(),
7606 user_address: "0xtest",
7607 user_api_key: "00000000-0000-0000-0000-000000000001",
7608 };
7609 let mut state = WsDispatchState::default();
7610
7611 let trade = PolymarketUserTrade {
7612 asset_id,
7613 bucket_index: 0,
7614 fee_rate_bps: "0".to_string(),
7615 id: "trade-one-shot-dust".to_string(),
7616 last_update: "1700000001".to_string(),
7617 maker_address: Ustr::from("0xmaker"),
7618 maker_orders: vec![],
7619 market: Ustr::from("0xmarket"),
7620 match_time: "1700000000".to_string(),
7621 outcome: PolymarketOutcome::yes(),
7622 owner: Ustr::from("00000000-0000-0000-0000-000000000001"),
7623 price: "0.963".to_string(),
7624 side: if order_side == OrderSide::Buy {
7625 PolymarketOrderSide::Buy
7626 } else {
7627 PolymarketOrderSide::Sell
7628 },
7629 size: fill_qty.to_string(),
7630 status: PolymarketTradeStatus::Confirmed,
7631 taker_order_id: venue_order_id.as_str().to_string(),
7632 timestamp: "1700000000000".to_string(),
7633 trade_owner: Ustr::from("00000000-0000-0000-0000-000000000001"),
7634 transaction_hash: None,
7635 trader_side: PolymarketLiquiditySide::Taker,
7636 event_type: PolymarketEventType::Trade,
7637 };
7638
7639 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
7640
7641 let event = receiver.try_recv().expect("expected the venue fill event");
7642 match event {
7643 ExecutionEvent::Order(OrderEventAny::Filled(filled)) => {
7644 assert_eq!(
7645 filled.last_qty,
7646 Quantity::from_decimal_dp(
7647 Decimal::from_str_exact(fill_qty).unwrap(),
7648 instrument.size_precision(),
7649 )
7650 .unwrap(),
7651 );
7652 }
7653 other => panic!("expected filled event, was {other:?}"),
7654 }
7655
7656 if expect_normalization {
7657 let event = receiver.try_recv().expect("expected quantity update");
7658 match event {
7659 ExecutionEvent::Order(OrderEventAny::Updated(updated)) => {
7660 assert_eq!(
7661 updated.quantity,
7662 Quantity::new(5.202897, instrument.size_precision()),
7663 );
7664 assert_eq!(updated.venue_order_id, Some(venue_order_id));
7665 assert!(updated.reconciliation);
7666 }
7667 other => panic!("expected updated event, was {other:?}"),
7668 }
7669 assert!(
7670 fill_tracker
7671 .get_cumulative_filled(&venue_order_id)
7672 .is_none(),
7673 "order must be settled and removed from the tracker",
7674 );
7675 } else if expect_cancel {
7676 let event = receiver.try_recv().expect("expected IOC cancellation");
7677 match event {
7678 ExecutionEvent::Order(OrderEventAny::Canceled(canceled)) => {
7679 assert_eq!(canceled.venue_order_id, Some(venue_order_id));
7680 }
7681 other => panic!("expected canceled event, was {other:?}"),
7682 }
7683 assert!(
7684 fill_tracker
7685 .get_cumulative_filled(&venue_order_id)
7686 .is_none(),
7687 "canceled IOC must be settled and removed from the tracker",
7688 );
7689 } else {
7690 assert!(
7691 receiver.try_recv().is_err(),
7692 "resting order must not receive a terminal event",
7693 );
7694 assert!(
7695 fill_tracker
7696 .get_cumulative_filled(&venue_order_id)
7697 .is_some(),
7698 "ineligible order must stay tracked with open leaves",
7699 );
7700 }
7701 }
7702
7703 #[rstest]
7704 fn test_dispatch_taker_fill_gross_overfill_raises_qty_then_fills() {
7705 use crate::common::enums::{
7709 PolymarketEventType, PolymarketOrderSide, PolymarketOutcome, PolymarketTradeStatus,
7710 };
7711
7712 let instrument = bind_instrument(test_instrument(), "0xmarket", PolymarketOutcome::yes());
7713 let asset_id = instrument.id().symbol.inner();
7714 let size_precision = instrument.size_precision();
7715 let token_instruments = AtomicMap::new();
7716 token_instruments.insert(asset_id, instrument.clone());
7717
7718 let fill_tracker = OrderFillTrackerMap::new();
7719 let venue_order_id = VenueOrderId::from("0xtaker-gross-overfill");
7720 let submitted = Quantity::new(30.0, size_precision);
7721 fill_tracker.register(
7722 venue_order_id,
7723 submitted,
7724 OrderSide::Buy,
7725 instrument.id(),
7726 size_precision,
7727 instrument.price_precision(),
7728 );
7729
7730 let pending_submits = PendingSubmitTracker::default();
7731 let order_contexts = OrderContextRegistry::default();
7732 register_context(
7733 &order_contexts,
7734 venue_order_id,
7735 instrument.id(),
7736 "O-GROSS-OVERFILL",
7737 );
7738 order_contexts.mark_accepted(venue_order_id);
7739 let mut emitter = test_emitter();
7740 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
7741 emitter.set_sender(sender);
7742
7743 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
7744 settlement.mark_live();
7745 settlement.note_order_submitted(venue_order_id);
7746
7747 let ctx = WsDispatchContext {
7748 signer_type: PolymarketSignerType::Owner,
7749 token_instruments: &token_instruments,
7750 fill_tracker: &fill_tracker,
7751 settlement: &settlement,
7752 pending_submits: &pending_submits,
7753 order_contexts: &order_contexts,
7754 emitter: &emitter,
7755 account_id: AccountId::from("POLY-001"),
7756 clock: nautilus_core::time::get_atomic_clock_realtime(),
7757 user_address: "0xtest",
7758 user_api_key: "00000000-0000-0000-0000-000000000001",
7759 };
7760 let mut state = WsDispatchState::default();
7761
7762 let trade = PolymarketUserTrade {
7764 asset_id,
7765 bucket_index: 0,
7766 fee_rate_bps: "0".to_string(),
7767 id: "trade-gross-overfill".to_string(),
7768 last_update: "1700000001".to_string(),
7769 maker_address: Ustr::from("0xmaker"),
7770 maker_orders: vec![],
7771 market: Ustr::from("0xmarket"),
7772 match_time: "1700000000".to_string(),
7773 outcome: PolymarketOutcome::yes(),
7774 owner: Ustr::from("00000000-0000-0000-0000-000000000001"),
7775 price: "0.014".to_string(),
7776 side: PolymarketOrderSide::Buy,
7777 size: "33.846152".to_string(),
7778 status: PolymarketTradeStatus::Confirmed,
7779 taker_order_id: venue_order_id.as_str().to_string(),
7780 timestamp: "1700000000000".to_string(),
7781 trade_owner: Ustr::from("00000000-0000-0000-0000-000000000001"),
7782 transaction_hash: None,
7783 trader_side: PolymarketLiquiditySide::Taker,
7784 event_type: PolymarketEventType::Trade,
7785 };
7786
7787 dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
7788
7789 let expected_qty = Quantity::new(33.846152, size_precision);
7790
7791 match receiver.try_recv().expect("expected an updated event") {
7793 ExecutionEvent::Order(OrderEventAny::Updated(updated)) => {
7794 assert_eq!(updated.quantity, expected_qty);
7795 assert_eq!(updated.venue_order_id, Some(venue_order_id));
7796 }
7797 other => panic!("expected updated event raising qty to the fill, was {other:?}"),
7798 }
7799
7800 match receiver.try_recv().expect("expected a filled event") {
7801 ExecutionEvent::Order(OrderEventAny::Filled(filled)) => {
7802 assert_eq!(filled.last_qty, expected_qty);
7803 assert_eq!(filled.venue_order_id, venue_order_id);
7804 }
7805 other => panic!("expected filled event, was {other:?}"),
7806 }
7807 }
7808
7809 #[rstest]
7812 #[case(
7813 crate::common::enums::PolymarketOrderStatus::Unmatched,
7814 Some("invalid post-only order: order crosses book"),
7815 "Rejected"
7816 )]
7817 #[case(
7818 crate::common::enums::PolymarketOrderStatus::CanceledMarketResolved,
7819 None,
7820 "Expired"
7821 )]
7822 fn test_dispatch_order_terminal_status_emits_event(
7823 #[case] status: crate::common::enums::PolymarketOrderStatus,
7824 #[case] reason: Option<&str>,
7825 #[case] expected: &str,
7826 ) {
7827 use crate::common::enums::{
7828 PolymarketEventType, PolymarketOrderSide, PolymarketOrderType, PolymarketOutcome,
7829 };
7830
7831 let instrument = test_instrument();
7832 let asset_id = instrument.id().symbol.inner();
7833 let order_id = "0xterminal-order".to_string();
7834 let venue_order_id = VenueOrderId::from(order_id.as_str());
7835
7836 let token_instruments = AtomicMap::new();
7837 token_instruments.insert(asset_id, instrument.clone());
7838
7839 let fill_tracker = OrderFillTrackerMap::new();
7840 fill_tracker.register(
7841 venue_order_id,
7842 Quantity::from("10"),
7843 OrderSide::Buy,
7844 instrument.id(),
7845 instrument.size_precision(),
7846 instrument.price_precision(),
7847 );
7848
7849 let pending_submits = PendingSubmitTracker::default();
7850 let order_contexts = OrderContextRegistry::default();
7851 register_context(
7852 &order_contexts,
7853 venue_order_id,
7854 instrument.id(),
7855 "O-TERMINAL",
7856 );
7857 order_contexts.mark_accepted(venue_order_id);
7858 let mut emitter = test_emitter();
7859 let (sender, mut receiver) = tokio::sync::mpsc::unbounded_channel();
7860 emitter.set_sender(sender);
7861
7862 let settlement = SettlementRegistry::new(AccountId::from("POLY-001"));
7863 settlement.mark_live();
7864 settlement.note_order_submitted(venue_order_id);
7865
7866 let ctx = WsDispatchContext {
7867 signer_type: PolymarketSignerType::Owner,
7868 token_instruments: &token_instruments,
7869 fill_tracker: &fill_tracker,
7870 settlement: &settlement,
7871 pending_submits: &pending_submits,
7872 order_contexts: &order_contexts,
7873 emitter: &emitter,
7874 account_id: AccountId::from("POLY-001"),
7875 clock: nautilus_core::time::get_atomic_clock_realtime(),
7876 user_address: "0xabc",
7877 user_api_key: "xxx",
7878 };
7879 let mut state = WsDispatchState::default();
7880
7881 let order = PolymarketUserOrder {
7882 asset_id,
7883 associate_trades: None,
7884 created_at: Some("1775074735".to_string()),
7885 expiration: Some("0".to_string()),
7886 id: order_id,
7887 maker_address: Some(Ustr::from("0xabc")),
7888 market: Ustr::from("0x4134"),
7889 order_owner: Some(Ustr::from("xxx")),
7890 order_type: Some(PolymarketOrderType::FOK),
7891 original_size: "10".to_string(),
7892 outcome: Some(PolymarketOutcome::yes()),
7893 owner: Ustr::from("xxx"),
7894 price: "0.50".to_string(),
7895 side: PolymarketOrderSide::Buy,
7896 size_matched: "0".to_string(),
7897 status: Some(PolymarketUserOrderStatus::new(status, reason)),
7898 timestamp: "1775074738031".to_string(),
7899 event_type: PolymarketEventType::Placement,
7900 };
7901
7902 dispatch_user_message(&UserWsMessage::Order(order), &ctx, &mut state);
7903
7904 let event = receiver.try_recv().expect("expected terminal order event");
7905 match event {
7906 ExecutionEvent::Order(order_event) => {
7907 assert!(
7908 format!("{order_event:?}").starts_with(expected),
7909 "expected {expected}, was {order_event:?}"
7910 );
7911 assert_eq!(
7912 order_event.client_order_id(),
7913 ClientOrderId::from("O-TERMINAL")
7914 );
7915
7916 if let OrderEventAny::Rejected(rejected) = order_event {
7917 assert_eq!(
7918 rejected.reason,
7919 "invalid post-only order: order crosses book"
7920 );
7921 assert!(rejected.due_post_only);
7922 }
7923 }
7924 other => panic!("expected order event, was {other:?}"),
7925 }
7926 }
7927}