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