Skip to main content

nautilus_polymarket/websocket/
dispatch.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! WebSocket message dispatch for the Polymarket execution client.
17//!
18//! Routes user-channel WS messages (order updates and trades) for orders submitted through this
19//! client into Nautilus order events (`OrderAccepted` / `OrderFilled` / `OrderFillVoided` /
20//! `OrderCanceled` / `OrderRejected` / `OrderExpired`), building them from the context captured at
21//! submit (`OrderContextRegistry`). Order-channel messages drive lifecycle events; trade-channel
22//! messages drive fills, and acceptance is synthesized before a fill or cancel that races ahead.
23//! Messages are emitted once the order is known (accepted, or with a submit in flight), otherwise
24//! buffered until acceptance. Reports are reserved for the `generate_*` query and reconciliation
25//! methods.
26//!
27//! Trade evidence is admitted through the shared settlement boundary and governed by the
28//! settlement registry: provisional and confirmed stream statuses apply legs once per
29//! uninterrupted session, failed or conflicting stream evidence quarantines the trade for
30//! targeted terminal REST resolution, and only a REST-established `FAILED` outcome voids
31//! applied fills or tombstones absent legs.
32//!
33//! Execution-client and dispatch replacement confirmations share one promotion under the dispatch
34//! lock. Execution-client confirmation uses logical-order context and local event time. Dispatch
35//! confirmation uses old-leg context and stream or REST evidence time, with local time as fallback
36//! for invalid order-update timestamps. Promotion publishes `OrderUpdated` before registering and
37//! releasing fills.
38//!
39//! Execution-client confirmation drains the returned activity immediately; dispatch handlers retain
40//! their own emission order. Execution-client confirmation sets drained fill `ts_init` at emission;
41//! dispatch preserves buffered `ts_init`.
42
43use 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/// Signal returned when a user event requires an async account refresh.
100#[derive(Debug)]
101pub(crate) struct AccountRefreshRequest;
102
103/// Mutable state retained across user WebSocket stream generations.
104///
105/// Terminal cancel reports are re-emitted after fills to restore terminal state when fills race
106/// ahead of or arrive after cancel messages.
107#[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    /// Promotes the winning replacement and releases its buffered activity after `OrderUpdated`.
202    ///
203    /// Source context resolution follows the consuming claim. Event time is resolved after
204    /// context registration, while initialization time uses the caller's local clock.
205    ///
206    /// # Errors
207    ///
208    /// Returns `None` if no pending replacement matches or its source context cannot be resolved.
209    /// Failed context resolution still consumes the claim.
210    #[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/// Buffered activity released by a replacement promotion after its update is published.
568#[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
581/// Immutable context borrowed from the async block's owned values.
582pub(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
626/// Top-level router: synchronous, returns signal for async account refresh.
627pub(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    // Order updates can race ahead of trade messages, so cap filled_qty
717    // to what the fill tracker has recorded to prevent duplicate inferred fills
718    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    // Track cancel reports so we can re-emit them after late-arriving fills.
730    // Saved regardless of acceptance state so that cancels arriving during
731    // the HTTP round-trip are available once the order is later accepted.
732    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    // Tracked own orders route through order events; externally-managed orders
747    // (no captured context) buffer until accepted or fall back to reports.
748    let context = ctx.order_contexts.get(&venue_order_id);
749
750    // Emit fills first: a terminal status would otherwise close the order ahead of them
751    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        // Registered between the early accepted-check and here: emit rather than buffer
790        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
810/// Takes the buffered fills released by an order status update and reports whether the order is
811/// accepted; a known own order (submit in flight or outcome unknown) self-registers on its first
812/// update.
813fn 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
949/// Routes a buffered fill for an order without captured context through the report path, if
950/// its trade still permits application.
951fn 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
1008/// Emits the terminal order event for a taker order once its trade confirms.
1009///
1010/// Taker fills receive no order-channel `MATCHED` update. FOK is atomic, so a sub-cent quantity
1011/// difference can be normalized. IOC maps to FAK, so every positive remainder was killed by the
1012/// venue and must close as `Canceled` without changing the venue-reported fill quantity. A hard
1013/// fault withdraws that authority and does not consume the tracker's one emission.
1014fn 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    // Quantity normalization and taker terminal statuses key off trade confirmation,
1089    // and a hard fault keeps the confirmed outcome while withdrawing that bookkeeping.
1090    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
1101/// Executes the effects a registry transition authorized, in order.
1102pub(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
1132/// Applies a targeted REST trade result through the settlement registry, then runs the same
1133/// confirmation bookkeeping as a stream confirmation once the trade is confirmed.
1134///
1135/// Evidence that fails admission leaves the trade pending for the next targeted read.
1136pub(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
1157/// Applies REST evidence for an order whose submit outcome was unknown, returning `true` once
1158/// its venue state is applied.
1159///
1160/// Terminal trades pass through the settlement registry first, so their fills queue behind the
1161/// order's acceptance; the order status then registers and accepts the order and releases them.
1162/// The status is withheld while any trade of the order is still provisional, or while confirmed
1163/// trades do not yet cover the venue's matched quantity, so the order never reports a state
1164/// ahead of its fills. Locally closed orders and replaced-leg cancellations still apply trades
1165/// but do not emit the order status.
1166pub(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    // Venue `Matched` is not a cancel, and the parsed `Canceled` status is the IOC remainder rule
1218    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    // A filled taker order reaches the terminal normalization a stream confirmation would apply,
1228    // and this check also covers a faulted trade in this slice whose order was not stored.
1229    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
1256/// Applies REST trades for an order that was live while the user stream was disconnected,
1257/// returning `true` once they cover the venue's matched quantity.
1258///
1259/// Only trades the settlement registry has never seen are applied, so each missed fill applies
1260/// once and trades it already holds keep their established resolution. The order status is not
1261/// applied: the stream and reconciliation keep driving the lifecycle of an accepted order.
1262pub(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
1304/// Returns the captured context and instrument of a submitted order, or `None` when they are
1305/// unknown or its REST order evidence contradicts them.
1306fn 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
1332/// Admits the REST trades touching an order and passes each to `apply`, returning `true` once
1333/// every trade is terminal and the confirmed trades cover the venue's matched quantity.
1334///
1335/// Nothing is applied while any trade is still provisional.
1336fn 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    // REST can list the order as matched before its trades appear
1383    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
1395/// Returns the distinct REST trades touching `venue_order_id`, or `None` when pagination repeats
1396/// a trade with contradictory evidence.
1397fn 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
1423/// Converts an admitted leg into a fill report and routes it through the established emission
1424/// machinery: modify promotion first, then tracked-order emission or buffered delivery, with
1425/// report fallback for orders without captured context.
1426fn 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    // Already delivered through a reconciliation fill report
1436    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
1489/// Confirmation bookkeeping beyond the settlement registry: terminal quantity normalization
1490/// and taker terminal statuses once a trade confirms through stream or REST evidence.
1491fn 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
1544/// Re-emits a saved cancel report after a fill to restore terminal state.
1545///
1546/// When fills race ahead of (or arrive after) cancel messages, the order can
1547/// get stuck in `PartiallyFilled`. This re-emission ensures the execution
1548/// engine transitions the order back to `Canceled`.
1549///
1550/// Skips re-emission when the fill tracker shows the order is fully filled,
1551/// because `Filled` is already terminal and a spurious cancel would fail
1552/// the `Filled -> Canceled` state transition.
1553fn 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    // Unfilled FOK cancellations carry an empty size_matched in captured venue messages
1627    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
1673/// Maps a venue `CANCELED` on a GTD order to `Expired` once the cancel is in the expiry window.
1674///
1675/// Polymarket reports both a user cancel and a GTD expiry as `CANCELED`, and expires a GTD
1676/// order one minute before its stated expiration. A cancel earlier than that window stays
1677/// `Canceled`.
1678fn 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
1702/// Converts a venue-reported `original_size` on a user-channel order message into shares.
1703///
1704/// For the market order types (`FAK` and `FOK`) the venue echoes the signed `makerAmount`, which
1705/// for a BUY is the pUSD budget rather than a share count (see `compute_maker_taker_amounts`): a
1706/// BUY at 0.01 for 100 shares reports `1`. Dividing by the order price recovers the signed
1707/// `takerAmount`, which is the share quantity the client submitted.
1708///
1709/// A SELL signs shares as its maker amount and needs no conversion. Resting types (`GTC` and
1710/// `GTD`) report shares for both sides and pass through unchanged: converting a
1711/// share-denominated size would misreport every externally-managed resting order.
1712fn 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
1732/// Emits order events for a tracked own-order status update.
1733///
1734/// Order-channel messages drive lifecycle events only; fills arrive separately on the trade
1735/// channel as `OrderFilled`. `PartiallyFilled` / `Filled` statuses therefore emit no fill here,
1736/// they only ensure acceptance has been emitted so the order lifecycle stays well-formed.
1737fn 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
1769/// Emits `OrderAccepted` at most once for a tracked order across submit and stream evidence.
1770///
1771/// Locally closed orders consume the acceptance marker without emitting an event, so late fills
1772/// cannot replay acceptance even if the order subsequently reopens.
1773fn 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
1801/// Builds and emits an `OrderFilled` event for a tracked order, synthesizing acceptance first.
1802///
1803/// `info` carries the venue fill metadata (the raw trade fields) for trade-sourced fills, and is
1804/// `None` for order-path fills that have no originating trade payload.
1805fn 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    // Pending before sending, so a decline observed during delivery finds the leg in flight
1820    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
1854/// Emits the one required `OrderFillVoided` for an applied leg of a REST-established `FAILED`
1855/// trade, constructed from the canonical applied fill published by core.
1856pub(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
1895/// Flattens a REST trade report into a string map of venue fill metadata for
1896/// `OrderFilled.info`.
1897pub(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
1902/// Flattens a user trade into a string map of venue fill metadata for `OrderFilled.info`.
1903///
1904/// Mirrors the v1 adapter, which attaches the full raw trade to each fill it generates. Scalar
1905/// fields map to their string form; nested fields (such as `maker_orders`) become their JSON text.
1906fn 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
1924/// Emits an `OrderUpdated` raising the order quantity to the actual BUY fill, before the fill.
1925///
1926/// A Polymarket BUY is bounded by the USDC it spends, so a marketable fill below the limit price
1927/// returns more shares than the nominal quantity. The engine rejects a fill past the order
1928/// quantity, so the quantity is raised first. The price is left unchanged (`None`).
1929fn 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
1957/// Emits an order-only reconciliation update which cannot change strategy position.
1958fn 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    /// Registers a tracked-order context so the dispatch routes the order through events.
2087    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        // A resting BUY already reports shares, so its size passes through unconverted
2835        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    // A market-order-type BUY reports the signed pUSD maker amount, so shares come from
2999    // dividing by the price. A SELL and the resting types already report shares.
3000    #[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    // A non-terminating division still rounds to the instrument's size precision
3056    #[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        // No registration: the submit response has not landed, so the order update registers it
3099        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        // The venue reported 1.01 pUSD for the 101 shares submitted at 0.01
3136        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        // No context registered, so the order surfaces as a report for reconciliation
3165        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        // The venue match time, not the message timestamp or the local clock
3251        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        // Every raw trade field is captured (mirrors v1 info=msg.to_dict()).
3454        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        // Numeric fields flatten to their string form.
3462        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        // The `type` serde-rename key is preserved.
3469        assert_eq!(info[&Ustr::from("type")], Ustr::from("TRADE"));
3470        // Nested fields become their JSON text.
3471        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        // Order not registered in fill_tracker, so should be buffered
3516        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        // The tracked own order emits an OrderAccepted event carrying the client order ID.
3614        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        // First dispatch processes the trade
3993        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        // Second dispatch should be deduped, no additional fill
3997        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        // Matching evidence after quarantine remains REST-gated: no emission.
4071        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        // A fill rebuilt from the cache at a snapped quantity that REST would contradict
5261        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        // MATCHED applies once for a current-session order.
5380        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        // The applied fill resolves the pending application through observation.
5393        settlement.observe_fill_applied(&filled);
5394
5395        // A stream FAILED update quarantines; it never voids directly.
5396        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        // A targeted terminal REST FAILED result voids the observed fill once.
5410        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        // A stale MATCHED update after the terminal REST outcome is absorbed as a tombstone.
5451        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        // Register order so it is "accepted" but with no fills tracked
5625        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        // No context registered, so the order surfaces as a report (the external/reconciliation
5636        // fallback), where filled_qty is capped to tracked fills.
5637        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        // Register and record a partial fill (50 of 100)
5687        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        // No context registered, so the order surfaces as a report (the external/reconciliation
5699        // fallback), where filled_qty is capped to tracked fills.
5700        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        // Register order as accepted with original qty=100
5910        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        // Step 1: Dispatch cancel (simulates message A from the bug)
5947        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        // Step 2: Dispatch trade fill (simulates trade arriving after cancel)
5957        dispatch_user_message(&UserWsMessage::Trade(trade), &ctx, &mut state);
5958
5959        // Should get: filled event, then re-emitted canceled event
5960        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        // The old venue order filled 20 of 120, so the replacement carries the other 100
6611        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        // The reconciliation report already delivered the leg, so it does not block reports
7033        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        // Register with qty=25 matching the trade size so the fill completes the order
7049        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        // Cancel then fill that completes the order
7091        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        // Channel should be empty: no re-emitted cancel for a fully-filled order
7098        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        // Fill tracker has NO registration (simulates HTTP still in-flight)
7114        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 cancel while order is not yet accepted
7141        dispatch_user_message(&UserWsMessage::Order(cancel_order), &ctx, &mut state);
7142
7143        // Cancel should be buffered (not emitted) AND saved to terminal_cancel_reports
7144        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    // A trade landing before the submit response buffers its fill, so the order update that
7165    // registers the order must emit that fill before its own terminal status
7166    #[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        // No registration: the submit response has not landed
7188        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        // The trade arrives first and buffers its fill
7229        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        // The order update registers the order and drains the buffered fill
7252        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        // The engine's state machine is what proves the order actually closes
7297        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    /// Replays the exact 5-message WS sequence from issue #3797.
7315    ///
7316    /// Messages in arrival order:
7317    ///   (A) Order Canceled, size_matched=0
7318    ///   (B) Trade fill 1.219511 (maker side)
7319    ///   (C) Order Canceled, size_matched=1.219511
7320    ///   (D) Order Canceled, size_matched=2.560972 (capped to tracked)
7321    ///   (E) Trade fill 1.341461 (maker side)
7322    ///
7323    /// Without the fix, the order ends in PartiallyFilled after (E).
7324    /// With the fix, a re-emitted cancel after (E) restores Canceled.
7325    #[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        // (A) Cancel with size_matched=0
7439        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        // (B) Trade fill 1.219511
7451        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        // Re-emitted cancel after fill (B)
7462        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        // (C) Cancel with size_matched=1.219511
7471        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        // (D) Cancel with size_matched=2.560972 (capped to tracked 1.219511)
7483        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        // (E) Trade fill 1.341461
7495        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        // The fix: re-emitted cancel after (E) restores terminal state
7507        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        // No more events
7516        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        // Captured V2 market BUY: 5 pUSD at 0.66 signs 7.5757 shares, and the on-chain
7525        // `takerAmountFilled` was 7.575758 (`chain_order_filled_taker_fees.json`). The
7526        // order quantity rises to the fill so the engine accepts the venue quantity.
7527        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        // Takers receive no MATCHED order update. FOK is atomic, so a dust
7691        // difference normalizes the registered quantity. IOC maps to FAK, so
7692        // a positive remainder closes as Canceled without changing the fill.
7693        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        // A marketable BUY filled below its limit returns more shares than the nominal qty (a
7859        // gross overfill, beyond the dust band). The dispatcher must raise the order qty via
7860        // OrderUpdated before the OrderFilled, or the engine drops the fill as an overfill.
7861        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        // 33.846152 shares against a nominal 30: a marketable fill below the limit price.
7916        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        // The raise must precede the fill so the engine accepts the larger quantity.
7945        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    // Unmatched -> Rejected (placement never became live); CanceledMarketResolved -> Expired
7963    // (market settled). Both are tracked own-order terminal states emitted as order events.
7964    #[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}