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