Skip to main content

nautilus_betfair/
execution.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//! Live execution client for the Betfair adapter.
17//!
18//! # Submission gate
19//!
20//! The client halts new-order submissions whenever the execution stream is unavailable or
21//! recovering. `submit_order` and `submit_order_list` emit `OrderDenied` with
22//! `STREAM_RECONCILING`, while cancel and modify commands remain available. Transport availability
23//! alone does not reopen the gate: an active replacement socket remains halted until the order
24//! subscription is current and the matching recovery task dispatches mass status.
25//!
26//! # Reconnect recovery
27//!
28//! A transport loss or server `connectionClosed` status advances the reconciliation generation
29//! immediately. A replacement `Connection` raises `pending_resync`; a complete `SUB_IMAGE` or
30//! `RESUB_DELTA` queues the current generation once. Subsequent OCMs remain buffered until
31//! `process_pending_resync` runs on the engine thread. Connectivity polling and command or report
32//! entry points invoke it to synchronize OCM state from the cache and drain the buffer.
33//!
34//! The recovery task attempts to refresh the session, requests account state on a best-effort basis,
35//! and builds a mass status from `list_current_orders`. Recovery uses match-time ordering and
36//! bounded retries to include fills that completed and rolled off the unmatched book during the
37//! gap.
38//!
39//! Mass-status dispatch, fill-deduplication commit, and gate reopening share one generation check;
40//! the task does not wait for a separate cache-application acknowledgement. A newer transport loss
41//! or replacement connection cancels older work. Failed authentication, exhausted recovery, or a
42//! failed report dispatch leaves the gate closed until a later reconnect succeeds or the client
43//! disconnects. A keep-alive failure other than explicit `LoginFailed` continues recovery with the
44//! retained session.
45//!
46//! # Modify reconciliation
47//!
48//! An ambiguous replace or quantity reduction remains pending until OCM or `listCurrentOrders`
49//! confirms it; only a fully paginated response can prove the original order non-actionable.
50//! Reconciliation emits the resulting `OrderUpdated` directly and withholds active reports that
51//! would reapply or contradict that update. A terminal replacement report follows its
52//! `OrderUpdated` through the normal report path and enters terminal retention. A terminal reduction
53//! needs no preceding update; its confirmed quantity overrides Betfair's original stake in that
54//! report and later reports.
55//!
56//! Owned report tasks collect HTTP evidence without the live cache. Their core-thread continuation
57//! resolves identities and pending modifications against current OCM state. Ambiguous-replace
58//! rejections cover only the pending replacements captured during collection. The continuation
59//! queues modification events; only the execution engine applies those events.
60
61use std::{
62    fmt,
63    future::Future,
64    sync::{
65        Arc,
66        atomic::{AtomicBool, AtomicU64, Ordering},
67    },
68    time::Duration,
69};
70
71use ahash::{AHashMap, AHashSet};
72use async_trait::async_trait;
73use nautilus_common::{
74    clients::{ExecutionClient, ExecutionReportTask},
75    live::{
76        runner::{get_data_event_sender, get_exec_event_sender},
77        sender::EventSender,
78    },
79    messages::{
80        DataEvent, ExecutionReport,
81        execution::{
82            BatchCancelOrders, CancelAllOrders, CancelOrder, GenerateFillReports,
83            GenerateOrderStatusReport, GenerateOrderStatusReports, GeneratePositionStatusReports,
84            ModifyOrder, QueryOrder, SubmitOrder, SubmitOrderList,
85        },
86    },
87};
88use nautilus_core::{
89    DurationNanos, Params, UUID4, UnixNanos,
90    time::{AtomicTime, get_atomic_clock_realtime},
91};
92use nautilus_live::{
93    ExecutionClientCore, ExecutionEventEmitter, SocketControl,
94    execution::{failure::CommandFailure, reports::retain_order_status_reports},
95    task::{TaskGroup, TaskGroupGuard},
96};
97use nautilus_model::{
98    accounts::AccountAny,
99    data::Data,
100    enums::{AccountType, LiquiditySide, OmsType, OrderSide, OrderStatus, OrderType, TimeInForce},
101    events::{
102        AccountState, OrderAccepted, OrderCanceled, OrderDeniedReason, OrderEventAny,
103        OrderFillVoided, OrderFilled, OrderModifyRejected, OrderUpdated,
104    },
105    identifiers::{
106        AccountId, ClientId, ClientOrderId, InstrumentId, StrategyId, TradeId, Venue, VenueOrderId,
107    },
108    instruments::InstrumentAny,
109    orders::{Order, OrderAny},
110    reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
111    types::{AccountBalance, Currency, MarginBalance, Price, Quantity},
112};
113use nautilus_network::{SocketState, SocketStateSink};
114use parking_lot::Mutex;
115use rust_decimal::Decimal;
116use ustr::Ustr;
117
118use crate::{
119    common::{
120        consts::{
121            BETFAIR_VENUE, METHOD_CANCEL_ORDERS, METHOD_GET_ACCOUNT_FUNDS,
122            METHOD_LIST_CURRENT_ORDERS, METHOD_LIST_EVENTS, METHOD_LIST_MARKET_CATALOGUE,
123            METHOD_PLACE_ORDERS, METHOD_REPLACE_ORDERS,
124        },
125        credential::BetfairCredential,
126        enums::{
127            BetfairOrderStatus, BetfairOrderType, BetfairSide, BetfairTimeInForce, ChangeType,
128            ExecutionReportErrorCode, ExecutionReportStatus, InstructionReportErrorCode,
129            InstructionReportStatus, OrderBy, OrderProjection, PersistenceType, SegmentType,
130            SortDir, StreamingOrderStatus, StreamingSide,
131        },
132        parse::{
133            extract_market_id, extract_selection_id, make_customer_order_ref,
134            make_customer_order_ref_legacy, make_instrument_id, parse_account_state,
135            parse_betfair_price, parse_betfair_quantity, parse_betfair_timestamp,
136            parse_millis_timestamp,
137        },
138        types::{BetId, OrderSyncEntry, SelectionId},
139    },
140    config::BetfairExecutionClientConfig,
141    data::custom_data_with_instrument,
142    data_types::{BetfairOrderVoided, register_betfair_custom_data},
143    http::{
144        client::BetfairHttpClient,
145        error::BetfairHttpError,
146        models::{
147            AccountFundsResponse, CancelExecutionReport, CancelInstruction, CancelOrdersParams,
148            CurrentOrderSummary, CurrentOrderSummaryReport, Event, LimitOnCloseOrder, LimitOrder,
149            ListCurrentOrdersParams, ListMarketCatalogueParams, MarketCatalogue, MarketFilter,
150            MarketOnCloseOrder, MarketVersion, PlaceExecutionReport, PlaceInstruction,
151            PlaceInstructionReport, PlaceOrdersParams, ReplaceExecutionReport, ReplaceInstruction,
152            ReplaceInstructionReport, ReplaceOrdersParams, TimeRange,
153        },
154        parse::{parse_current_order_fill_report, parse_current_order_report},
155    },
156    stream::{
157        USER_STREAMS_ENDPOINT,
158        client::{BetfairStreamClient, HeartbeatTimeoutSource, StreamMessageHandler},
159        config::BetfairStreamConfig,
160        messages::{OCM, OrderMarketChange, OrderRunnerChange, StreamMessage, UnmatchedOrder},
161        ocm::{CustomerOrderRefResolution, OcmState},
162        parse::{
163            FillTracker, FillVoidAllocation, has_cancel_quantity, is_resting_sp_bet,
164            parse_order_status_report,
165        },
166    },
167};
168
169/// Betfair live execution client.
170#[derive(Debug)]
171pub struct BetfairExecutionClient {
172    core: ExecutionClientCore,
173    clock: &'static AtomicTime,
174    emitter: ExecutionEventEmitter,
175    http_client: Arc<BetfairHttpClient>,
176    stream_client: Option<Arc<BetfairStreamClient>>,
177    socket_control: Option<SocketControl>,
178    credential: BetfairCredential,
179    stream_config: BetfairStreamConfig,
180    config: BetfairExecutionClientConfig,
181    currency: Currency,
182    ocm_state: Arc<Mutex<OcmState>>,
183    pending_resync: Arc<AtomicBool>,
184    reconciliation_gate: Arc<ReconciliationGate>,
185    replay_buffer: Arc<Mutex<Vec<ReceivedOcm>>>,
186    session_tasks: TaskGroup,
187    pending_tasks: TaskGroup,
188    shutdown_errors: Vec<String>,
189    account_refresh_tx: Option<tokio::sync::mpsc::UnboundedSender<()>>,
190}
191
192impl BetfairExecutionClient {
193    /// Creates a new [`BetfairExecutionClient`] instance.
194    ///
195    /// # Errors
196    ///
197    /// Returns an error if the client or stream configuration is invalid.
198    pub fn new(
199        core: ExecutionClientCore,
200        http_client: BetfairHttpClient,
201        credential: BetfairCredential,
202        stream_config: BetfairStreamConfig,
203        config: BetfairExecutionClientConfig,
204        currency: Currency,
205    ) -> anyhow::Result<Self> {
206        config.validate()?;
207        stream_config.validate()?;
208
209        let clock = get_atomic_clock_realtime();
210        let emitter = ExecutionEventEmitter::new(
211            clock,
212            core.trader_id,
213            core.account_id,
214            AccountType::Betting,
215            None,
216        );
217        let socket_control = Some(SocketControl::new(
218            core.client_id,
219            Some(*BETFAIR_VENUE),
220            USER_STREAMS_ENDPOINT,
221        ));
222
223        let session_tasks = TaskGroup::new();
224        let pending_tasks = TaskGroup::new();
225
226        Ok(Self {
227            core,
228            clock,
229            emitter,
230            http_client: Arc::new(http_client),
231            stream_client: None,
232            socket_control,
233            credential,
234            stream_config,
235            config,
236            currency,
237            ocm_state: Arc::new(Mutex::new(OcmState::default())),
238            pending_resync: Arc::new(AtomicBool::new(false)),
239            reconciliation_gate: Arc::new(ReconciliationGate::default()),
240            replay_buffer: Arc::new(Mutex::new(Vec::new())),
241            session_tasks,
242            pending_tasks,
243            shutdown_errors: Vec::new(),
244            account_refresh_tx: None,
245        })
246    }
247
248    /// Returns true while new-order submissions are halted for stream recovery.
249    #[must_use]
250    pub fn is_reconciling(&self) -> bool {
251        self.reconciliation_gate.is_halted()
252    }
253
254    /// Waits for the reconciliation halt state to equal `expected`.
255    ///
256    /// Returns immediately if the gate is already in the expected state; otherwise
257    /// waits for a later transition. A transient expected state that is replaced
258    /// before this task observes it can be missed because transitions are not
259    /// recorded as history. This method has no internal timeout; callers wanting a
260    /// bound should wrap it in [`tokio::time::timeout`].
261    pub async fn wait_for_reconciliation_state(&self, expected: bool) {
262        wait_for_reconciliation_state(&self.reconciliation_gate, expected).await;
263    }
264
265    fn submissions_halted(&self) -> bool {
266        !self.core.is_connected()
267            || self.reconciliation_gate.is_halted()
268            || self
269                .stream_client
270                .as_ref()
271                .is_none_or(|client| !client.is_order_ready())
272    }
273
274    fn spawn_task<F>(&self, description: &'static str, fut: F)
275    where
276        F: Future<Output = anyhow::Result<()>> + Send + 'static,
277    {
278        let future = async move {
279            if let Err(e) = fut.await {
280                log::warn!("{description} failed: {e:?}");
281            }
282        };
283
284        if let Err(e) = self.pending_tasks.spawn(future) {
285            log::warn!("Skipping Betfair {description} after shutdown began: {e}");
286        }
287    }
288
289    fn reconcile_market_ids(&self) -> Option<Vec<String>> {
290        if self.config.reconcile_market_ids_only
291            && let Some(ids) = &self.config.reconcile_market_ids
292        {
293            return Some(ids.clone());
294        }
295        self.config.stream_market_ids_filter.clone()
296    }
297
298    /// Returns the market version for price protection on order placement.
299    ///
300    /// When `use_market_version` is enabled, reads the `version` field from
301    /// the instrument's `info` metadata. Betfair lapses orders submitted with
302    /// a stale version rather than matching against a moved book.
303    fn get_market_version(&self, instrument_id: &InstrumentId) -> Option<MarketVersion> {
304        if !self.config.use_market_version {
305            return None;
306        }
307
308        let cache = self.core.cache();
309        let instrument = cache.instrument(instrument_id)?;
310
311        if let InstrumentAny::Betting(betting) = instrument {
312            let version = betting.info.as_ref()?.get_i64("version")?;
313            return Some(MarketVersion {
314                version: Some(version),
315            });
316        }
317
318        None
319    }
320
321    /// Pre-populates OCM state from cached orders to prevent duplicate fills
322    /// and terminal events after reconnect.
323    fn sync_ocm_state_from_cache(&self) {
324        let cache = self.core.cache();
325        let venue = *BETFAIR_VENUE;
326        let orders = cache.orders(Some(&venue), None, None, None, None);
327        let (active_orders, mut closed_orders): (Vec<_>, Vec<_>) =
328            orders.into_iter().partition(|order| !order.is_closed());
329        closed_orders.retain(|order| order.venue_order_id().is_some());
330        closed_orders.sort_by_key(|order| (order.ts_last(), order.client_order_id()));
331        let retained_closed_start = closed_orders
332            .len()
333            .saturating_sub(OcmState::DEDUP_RETENTION);
334        let retained_orders = active_orders
335            .into_iter()
336            .chain(closed_orders.into_iter().skip(retained_closed_start))
337            .collect::<Vec<_>>();
338
339        let order_data = retained_orders
340            .iter()
341            .filter_map(|order| Self::order_sync_entry(order))
342            .collect::<Vec<_>>();
343
344        let mut state = self.ocm_state.lock();
345        state.sync_from_orders(&order_data);
346        Self::sync_cached_fills(
347            &mut state,
348            retained_orders
349                .iter()
350                .filter(|order| order.venue_order_id().is_some())
351                .map(|order| &**order),
352        );
353
354        log::debug!("Synced OCM state from {} cached orders", order_data.len());
355    }
356
357    fn order_sync_entry(order: &OrderAny) -> Option<OrderSyncEntry> {
358        let venue_order_id = order.venue_order_id()?;
359        let (filled_qty, avg_px) = Self::current_order_fill_state(order, venue_order_id);
360        let mut venue_order_ids = order
361            .venue_order_ids()
362            .into_iter()
363            .map(ToString::to_string)
364            .collect::<AHashSet<_>>();
365        venue_order_ids.extend(
366            order
367                .events()
368                .iter()
369                .filter_map(|event| event.venue_order_id())
370                .map(|venue_order_id| venue_order_id.to_string()),
371        );
372        let mut venue_order_ids = venue_order_ids.into_iter().collect::<Vec<_>>();
373        venue_order_ids.sort_unstable();
374
375        let trade_ids = order
376            .trade_ids()
377            .iter()
378            .map(|trade_id| trade_id.to_string())
379            .collect();
380
381        Some(OrderSyncEntry {
382            bet_id: venue_order_id.to_string(),
383            venue_order_ids,
384            client_order_id: order.client_order_id(),
385            strategy_id: order.strategy_id(),
386            filled_qty,
387            avg_px,
388            is_closed: order.is_closed(),
389            trade_ids,
390        })
391    }
392
393    fn current_order_fill_state(
394        order: &OrderAny,
395        venue_order_id: VenueOrderId,
396    ) -> (Decimal, Decimal) {
397        let events = order.events();
398        let mut latest_px = AHashMap::new();
399        let mut quantities = Vec::new();
400
401        for event in &events {
402            let OrderEventAny::Filled(fill) = event else {
403                continue;
404            };
405
406            if fill.venue_order_id != venue_order_id {
407                continue;
408            }
409
410            let price = fill.last_px.as_decimal();
411            if latest_px.insert(fill.trade_id, price).is_some() {
412                continue;
413            }
414
415            quantities.push((fill.trade_id, fill.last_qty.as_decimal()));
416        }
417
418        let mut voided_qty = AHashMap::new();
419
420        for event in &events {
421            let OrderEventAny::FillVoided(voided) = event else {
422                continue;
423            };
424
425            voided_qty.insert(voided.trade_id, voided.voided_qty.as_decimal());
426        }
427
428        let surviving: Vec<(TradeId, Decimal)> = quantities
429            .into_iter()
430            .filter_map(|(trade_id, quantity)| {
431                let remaining = quantity - voided_qty.get(&trade_id).copied().unwrap_or_default();
432                (remaining > Decimal::ZERO).then_some((trade_id, remaining))
433            })
434            .collect();
435
436        let filled_qty: Decimal = surviving.iter().map(|(_, quantity)| *quantity).sum();
437        let notional: Decimal = surviving
438            .iter()
439            .map(|(trade_id, quantity)| *quantity * latest_px[trade_id])
440            .sum();
441
442        if filled_qty > Decimal::ZERO {
443            return (filled_qty, notional / filled_qty);
444        }
445
446        if events
447            .iter()
448            .any(|event| matches!(event, OrderEventAny::Filled(_)))
449        {
450            return (Decimal::ZERO, Decimal::ZERO);
451        }
452
453        (
454            order.filled_qty().as_decimal(),
455            order.avg_px().unwrap_or(Decimal::ZERO),
456        )
457    }
458
459    fn sync_cached_fills<'a>(state: &mut OcmState, orders: impl IntoIterator<Item = &'a OrderAny>) {
460        let mut replay_fills = Vec::new();
461        let mut latest_px = AHashMap::new();
462        let mut voided_by_trade = AHashMap::new();
463
464        for order in orders {
465            for event in order.events() {
466                match event {
467                    OrderEventAny::Filled(fill) => {
468                        let key = (fill.venue_order_id.to_string(), fill.trade_id);
469                        if !latest_px.contains_key(&key) {
470                            replay_fills.push((
471                                key.0.clone(),
472                                fill.trade_id,
473                                fill.last_qty.as_decimal(),
474                                fill.last_px,
475                            ));
476                        }
477
478                        latest_px.insert(key, fill.last_px);
479                    }
480                    OrderEventAny::FillVoided(voided) => {
481                        voided_by_trade.insert(
482                            (voided.venue_order_id.to_string(), voided.trade_id),
483                            voided.voided_qty.as_decimal(),
484                        );
485                    }
486                    _ => {}
487                }
488            }
489        }
490
491        for (bet_id, trade_id, quantity, price) in replay_fills {
492            let voided_qty = voided_by_trade
493                .get(&(bet_id.clone(), trade_id))
494                .copied()
495                .unwrap_or(Decimal::ZERO);
496            state
497                .fill_tracker
498                .sync_fill_lot(&bet_id, trade_id, quantity, price, voided_qty);
499            if let Some(accounting_px) = latest_px.get(&(bet_id.clone(), trade_id))
500                && *accounting_px != price
501            {
502                state
503                    .fill_tracker
504                    .set_accounting_px(&bet_id, trade_id, *accounting_px);
505            }
506        }
507
508        state.fill_tracker.seed_missing_averages();
509        let mut voided_by_bet = AHashMap::<String, Decimal>::new();
510
511        for ((bet_id, _), voided_qty) in voided_by_trade {
512            *voided_by_bet.entry(bet_id).or_default() += voided_qty;
513        }
514
515        for (bet_id, voided_qty) in voided_by_bet {
516            state.fill_tracker.sync_voided_qty(&bet_id, voided_qty);
517        }
518    }
519
520    /// Resyncs OCM state from cache and drains any OCMs the network handler
521    /// buffered while waiting (cache is `!Send` so this must run on the
522    /// engine thread).
523    fn process_pending_resync(&self) {
524        if !self.core.is_connected() || self.reconciliation_gate.is_halted() {
525            return;
526        }
527
528        if !self.pending_resync.load(Ordering::Acquire) {
529            return;
530        }
531
532        let data_sender = get_data_event_sender();
533        let market_ids_filter = self
534            .config
535            .stream_market_ids_filter
536            .as_ref()
537            .map(|ids| ids.iter().cloned().collect::<ahash::AHashSet<String>>());
538
539        // Sync only at the start: per-iteration re-sync would clobber
540        // tracker updates `process_ocm` just made with a staler cache view.
541        self.sync_ocm_state_from_cache();
542
543        loop {
544            let mut buf = self.replay_buffer.lock();
545            if buf.is_empty() {
546                self.pending_resync.store(false, Ordering::Release);
547                return;
548            }
549
550            let drained: Vec<ReceivedOcm> = std::mem::take(&mut *buf);
551            drop(buf);
552
553            for received in drained {
554                Self::process_ocm(
555                    &received,
556                    self.core.account_id,
557                    self.currency,
558                    &self.emitter,
559                    &self.ocm_state,
560                    &data_sender,
561                    market_ids_filter.as_ref(),
562                    self.config.ignore_external_orders,
563                    self.account_refresh_tx.as_ref(),
564                );
565            }
566        }
567    }
568
569    /// Clears the resync flag and replay buffer so post-shutdown
570    /// `is_connected()` polls don't dispatch buffered OCMs.
571    fn clear_resync_state(&self) {
572        let mut buf = self.replay_buffer.lock();
573        buf.clear();
574        self.pending_resync.store(false, Ordering::Release);
575
576        self.reconciliation_gate.clear();
577    }
578
579    fn abort_pending_tasks(&self) {
580        self.pending_tasks.begin_shutdown();
581    }
582
583    fn abort_session_tasks(&mut self) {
584        self.session_tasks.begin_shutdown();
585        self.account_refresh_tx = None;
586    }
587
588    async fn await_pending_tasks(&self) -> anyhow::Result<()> {
589        self.pending_tasks.begin_shutdown();
590        self.pending_tasks
591            .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
592            .await
593            .map_err(|e| anyhow::anyhow!("Failed to terminate Betfair execution tasks: {e}"))?;
594        Ok(())
595    }
596
597    async fn await_session_tasks(&self) -> anyhow::Result<()> {
598        self.session_tasks.begin_shutdown();
599        self.session_tasks
600            .finish_shutdown(Duration::from_secs(1), Duration::from_secs(2))
601            .await
602            .map_err(|e| anyhow::anyhow!("Failed to terminate Betfair session tasks: {e}"))?;
603        Ok(())
604    }
605
606    async fn teardown_partial_connect(&mut self) -> anyhow::Result<()> {
607        self.abort_session_tasks();
608        self.abort_pending_tasks();
609
610        if let Some(control) = &self.socket_control {
611            control.deregister();
612        }
613
614        if let Some(client) = self.stream_client.as_ref() {
615            match client.close().await {
616                Ok(()) => self.stream_client = None,
617                Err(e) => self
618                    .shutdown_errors
619                    .push(format!("stream shutdown failed: {e}")),
620            }
621        }
622
623        self.http_client.disconnect().await;
624        let (session_result, pending_result) =
625            tokio::join!(self.await_session_tasks(), self.await_pending_tasks());
626        self.core.set_disconnected();
627        self.clear_resync_state();
628
629        if let Err(e) = session_result {
630            self.shutdown_errors.push(e.to_string());
631        }
632
633        if let Err(e) = pending_result {
634            self.shutdown_errors.push(e.to_string());
635        }
636
637        if self.shutdown_errors.is_empty() {
638            Ok(())
639        } else {
640            let errors = std::mem::take(&mut self.shutdown_errors);
641            anyhow::bail!("Betfair execution shutdown failed: {}", errors.join("; "))
642        }
643    }
644
645    #[expect(clippy::too_many_arguments)]
646    fn create_ocm_handler(
647        emitter: ExecutionEventEmitter,
648        account_id: AccountId,
649        currency: Currency,
650        ocm_state: Arc<Mutex<OcmState>>,
651        data_sender: EventSender<DataEvent>,
652        market_ids_filter: Option<ahash::AHashSet<String>>,
653        ignore_external_orders: bool,
654        reconnect_tx: tokio::sync::mpsc::UnboundedSender<u64>,
655        queued_generation: Arc<AtomicU64>,
656        pending_resync: Arc<AtomicBool>,
657        reconciliation_gate: Arc<ReconciliationGate>,
658        replay_buffer: Arc<Mutex<Vec<ReceivedOcm>>>,
659        account_refresh_tx: tokio::sync::mpsc::UnboundedSender<()>,
660        clock: &'static AtomicTime,
661    ) -> StreamMessageHandler {
662        let has_initial_connection = Arc::new(AtomicBool::new(false));
663        let order_degraded = AtomicBool::new(false);
664
665        Arc::new(move |msg: StreamMessage| {
666            let ts_init = clock.get_time_ns();
667
668            match msg {
669                StreamMessage::OrderChange(ocm) => {
670                    let complete =
671                        ocm.segment_type.is_none() || ocm.segment_type == Some(SegmentType::SegEnd);
672                    let current_image = ocm.status.is_none()
673                        && matches!(ocm.ct, Some(ChangeType::SubImage | ChangeType::ResubDelta))
674                        && complete;
675                    let recovered_from_degradation = ocm.status.is_none()
676                        && complete
677                        && order_degraded.swap(false, Ordering::AcqRel);
678                    if ocm.status == Some(503) && !order_degraded.swap(true, Ordering::AcqRel) {
679                        reconciliation_gate.halt();
680                        pending_resync.store(true, Ordering::Release);
681                    }
682
683                    if pending_resync.load(Ordering::Acquire)
684                        && (current_image || recovered_from_degradation)
685                    {
686                        let generation = reconciliation_gate.current_generation();
687                        if queued_generation.swap(generation, Ordering::AcqRel) != generation
688                            && reconnect_tx.send(generation).is_err()
689                        {
690                            log::warn!("Failed to schedule Betfair reconnect reconciliation");
691                        }
692                    }
693
694                    if ocm.status == Some(503) {
695                        return;
696                    }
697
698                    if ocm.is_heartbeat() {
699                        return;
700                    }
701
702                    let received = ReceivedOcm {
703                        message: ocm,
704                        ts_init,
705                    };
706
707                    // Lock spans the flag check so the drainer's clear-flag
708                    // step cannot race a producer push
709                    let mut buf = replay_buffer.lock();
710                    if pending_resync.load(Ordering::Acquire) {
711                        buf.push(received);
712                        return;
713                    }
714                    drop(buf);
715
716                    Self::process_ocm(
717                        &received,
718                        account_id,
719                        currency,
720                        &emitter,
721                        &ocm_state,
722                        &data_sender,
723                        market_ids_filter.as_ref(),
724                        ignore_external_orders,
725                        Some(&account_refresh_tx),
726                    );
727                }
728                StreamMessage::Connection(_) => {
729                    order_degraded.store(false, Ordering::Release);
730                    let initial = !has_initial_connection.swap(true, Ordering::SeqCst)
731                        && !reconciliation_gate.is_halted();
732
733                    if initial {
734                        log::debug!("Betfair execution stream connected");
735                    } else {
736                        log::info!("Betfair execution stream reconnected");
737
738                        if !reconciliation_gate.is_halted() {
739                            reconciliation_gate.halt();
740                        }
741                        pending_resync.store(true, Ordering::Release);
742                    }
743                }
744                StreamMessage::Status(status) => {
745                    if status.connection_closed {
746                        reconciliation_gate.halt();
747                        pending_resync.store(true, Ordering::Release);
748                        log::warn!(
749                            "Betfair execution stream closed: {:?} - {:?}",
750                            status.error_code,
751                            status.error_message,
752                        );
753                    }
754                }
755                StreamMessage::MarketChange(_)
756                | StreamMessage::RaceChange(_)
757                | StreamMessage::CricketChange(_) => {}
758            }
759        })
760    }
761
762    #[expect(clippy::too_many_arguments)]
763    fn process_ocm(
764        received: &ReceivedOcm,
765        account_id: AccountId,
766        currency: Currency,
767        emitter: &ExecutionEventEmitter,
768        ocm_state: &Arc<Mutex<OcmState>>,
769        data_sender: &EventSender<DataEvent>,
770        market_ids_filter: Option<&ahash::AHashSet<String>>,
771        ignore_external_orders: bool,
772        account_refresh_tx: Option<&tokio::sync::mpsc::UnboundedSender<()>>,
773    ) {
774        let ocm = &received.message;
775        let Some(order_changes) = &ocm.oc else {
776            return;
777        };
778
779        let ts_event = parse_millis_timestamp(ocm.pt);
780        let ts_init = received.ts_init;
781
782        let context = OcmProcessingContext {
783            account_id,
784            currency,
785            emitter,
786            ocm_state,
787            data_sender,
788            ignore_external_orders,
789            account_refresh_tx,
790            ts_event,
791            ts_init,
792        };
793
794        for omc in order_changes {
795            Self::process_order_market_change(omc, market_ids_filter, &context);
796        }
797    }
798
799    fn process_order_market_change(
800        omc: &OrderMarketChange,
801        market_ids_filter: Option<&ahash::AHashSet<String>>,
802        context: &OcmProcessingContext<'_>,
803    ) {
804        if market_ids_filter.is_some_and(|filter| !filter.contains(&omc.id)) {
805            return;
806        }
807
808        for runner_change in omc.orc.as_deref().unwrap_or_default() {
809            Self::process_order_runner_change(&omc.id, runner_change, context);
810        }
811    }
812
813    fn process_order_runner_change(
814        market_id: &str,
815        runner_change: &OrderRunnerChange,
816        context: &OcmProcessingContext<'_>,
817    ) {
818        let handicap = runner_change.hc.unwrap_or(Decimal::ZERO);
819        let instrument_id = make_instrument_id(market_id, runner_change.id, handicap);
820
821        for order in runner_change.uo.as_deref().unwrap_or_default() {
822            let has_customer_ref = order
823                .rfo
824                .as_deref()
825                .is_some_and(|customer_ref| !customer_ref.is_empty());
826
827            if context.ignore_external_orders && !has_customer_ref {
828                continue;
829            }
830
831            let processed = Self::process_unmatched_order(
832                order,
833                instrument_id,
834                context.account_id,
835                context.currency,
836                context.emitter,
837                context.ocm_state,
838                context.ts_event,
839                context.ts_init,
840            );
841
842            if processed
843                && order.sv.is_some_and(|size| size > Decimal::ZERO)
844                && let Some(tx) = context.account_refresh_tx
845            {
846                let _ = tx.send(());
847            }
848
849            Self::publish_legacy_order_voided(order, instrument_id, context);
850        }
851    }
852
853    fn publish_legacy_order_voided(
854        order: &UnmatchedOrder,
855        instrument_id: InstrumentId,
856        context: &OcmProcessingContext<'_>,
857    ) {
858        if order.status != StreamingOrderStatus::ExecutionComplete {
859            return;
860        }
861
862        let Some(size_voided) = order.sv.filter(|size| *size > Decimal::ZERO) else {
863            return;
864        };
865
866        let side = match order.side {
867            StreamingSide::Back => "BACK",
868            StreamingSide::Lay => "LAY",
869        };
870
871        let voided = BetfairOrderVoided::new(
872            instrument_id,
873            order.rfo.as_deref().unwrap_or("").to_string(),
874            order.id.clone(),
875            size_voided,
876            order.p,
877            order.s,
878            side.to_string(),
879            order.avp,
880            order.sm,
881            String::new(),
882            context.ts_event,
883            context.ts_init,
884        );
885
886        log::debug!(
887            "Order voided: bet_id={}, size_voided={size_voided}",
888            order.id
889        );
890
891        let custom = custom_data_with_instrument(Arc::new(voided), instrument_id);
892
893        if let Err(e) = context
894            .data_sender
895            .send(DataEvent::Data(Data::Custom(custom)))
896        {
897            log::warn!("Failed to send voided event: {e}");
898        }
899    }
900
901    #[expect(clippy::too_many_arguments)]
902    fn process_unmatched_order(
903        uo: &UnmatchedOrder,
904        instrument_id: InstrumentId,
905        account_id: AccountId,
906        currency: Currency,
907        emitter: &ExecutionEventEmitter,
908        ocm_state: &Arc<Mutex<OcmState>>,
909        ts_event: UnixNanos,
910        ts_init: UnixNanos,
911    ) -> bool {
912        let context = UnmatchedOrderContext {
913            order: uo,
914            instrument_id,
915            account_id,
916            currency,
917            emitter,
918            ts_event,
919            ts_init,
920        };
921        let mut report =
922            match parse_order_status_report(uo, instrument_id, account_id, ts_event, ts_init) {
923                Ok(report) => report,
924                Err(e) => {
925                    log::warn!("Failed to parse order status report for {instrument_id}: {e}");
926                    return false;
927                }
928            };
929
930        let mut state = ocm_state.lock();
931
932        if state.is_redundant_terminal_update(uo) {
933            return false;
934        }
935
936        let owner = state.resolve_order_owner(uo.rfo.as_deref(), &uo.id);
937        let resolved_client_order_id = owner.and_then(CustomerOrderRefResolution::client_order_id);
938
939        // Ambiguity clears the parser-derived client ID so routing falls back to Bet ID
940        if owner.is_some() {
941            report.client_order_id = resolved_client_order_id;
942        }
943
944        let cancel_action = resolve_cancel_action(&state, uo, resolved_client_order_id.as_ref());
945
946        if cancel_action == CancelAction::Suppress {
947            log::debug!(
948                "Suppressing cancel for bet_id={} (pending replace or already replaced)",
949                uo.id,
950            );
951
952            if let Some(client_order_id) = resolved_client_order_id {
953                state.retain_terminal_order(client_order_id, &uo.id);
954            }
955        }
956
957        // Tracked orders take the direct-event path, not reports (routing contract,
958        // developer_guide/adapters.md): direct terminal events stay authoritative instead
959        // of being deferred by reconciliation while the order is locally `PendingCancel`.
960        let tracked = resolved_client_order_id.and_then(|client_oid| {
961            state
962                .order_strategy_id(&client_oid)
963                .map(|strategy_id| (client_oid, strategy_id))
964        });
965
966        if cancel_action == CancelAction::Suppress && tracked.is_none() {
967            return false;
968        }
969
970        if let Some((client_order_id, strategy_id)) = tracked
971            && let Some((total_quantity, _)) =
972                state.promote_pending_replace(&client_order_id, &uo.id, report.quantity)
973        {
974            let updated = OrderUpdated::new(
975                context.emitter.trader_id(),
976                strategy_id,
977                context.instrument_id,
978                client_order_id,
979                total_quantity,
980                UUID4::new(),
981                report.ts_last,
982                context.ts_init,
983                false,
984                Some(report.venue_order_id),
985                Some(context.account_id),
986                report.price,
987                None,
988                None,
989                false,
990            );
991            context
992                .emitter
993                .send_order_event(OrderEventAny::Updated(updated));
994        }
995
996        if let Some((client_order_id, strategy_id, quantity)) =
997            Self::resolve_pending_reduction_from_stream(&mut state, tracked, uo)
998        {
999            let updated = OrderUpdated::new(
1000                context.emitter.trader_id(),
1001                strategy_id,
1002                context.instrument_id,
1003                client_order_id,
1004                quantity,
1005                UUID4::new(),
1006                report.ts_last,
1007                context.ts_init,
1008                false,
1009                Some(report.venue_order_id),
1010                Some(context.account_id),
1011                None,
1012                None,
1013                None,
1014                false,
1015            );
1016            context
1017                .emitter
1018                .send_order_event(OrderEventAny::Updated(updated));
1019        }
1020
1021        let (fill, fill_voids, price_restatement) = Self::derive_fill_changes(&context, &mut state);
1022
1023        if report.order_status == OrderStatus::Canceled
1024            && let Some(reason) = report.cancel_reason.as_deref()
1025        {
1026            log::debug!(
1027                "Betfair order {} ({}) canceled: reason={}, matched={}, canceled={}, lapsed={}, voided={}",
1028                report
1029                    .client_order_id
1030                    .unwrap_or_else(|| ClientOrderId::from(uo.id.as_str())),
1031                uo.id,
1032                reason,
1033                uo.sm.unwrap_or(Decimal::ZERO),
1034                uo.sc.unwrap_or(Decimal::ZERO),
1035                uo.sl.unwrap_or(Decimal::ZERO),
1036                uo.sv.unwrap_or(Decimal::ZERO),
1037            );
1038        }
1039
1040        let emitted = if let Some((client_order_id, strategy_id)) = tracked {
1041            Self::emit_tracked_order_events(
1042                &context,
1043                &mut state,
1044                &report,
1045                client_order_id,
1046                strategy_id,
1047                fill,
1048                fill_voids,
1049                cancel_action,
1050                price_restatement,
1051            )
1052        } else {
1053            Self::emit_untracked_order_reports(&context, report, fill);
1054            true
1055        };
1056
1057        if !emitted {
1058            return false;
1059        }
1060
1061        if uo.status == StreamingOrderStatus::ExecutionComplete
1062            && !is_resting_sp_bet(uo)
1063            && cancel_action != CancelAction::Suppress
1064        {
1065            if let Some(client_order_id) =
1066                resolved_client_order_id.or_else(|| state.client_order_id_by_venue_order_id(&uo.id))
1067            {
1068                state.retain_terminal_order(client_order_id, &uo.id);
1069            } else {
1070                state.mark_terminal_order(uo.id.clone());
1071            }
1072            state.clear_canceled_replace(&uo.id);
1073        }
1074
1075        true
1076    }
1077
1078    fn resolve_pending_reduction_from_stream(
1079        state: &mut OcmState,
1080        tracked: Option<(ClientOrderId, StrategyId)>,
1081        order: &UnmatchedOrder,
1082    ) -> Option<(ClientOrderId, StrategyId, Quantity)> {
1083        let (client_order_id, strategy_id) = tracked?;
1084        let active_quantity = parse_betfair_quantity(
1085            stream_active_quantity(order)?.as_decimal()
1086                + state.replaced_matched_quantity(&client_order_id)
1087                + state.replaced_voided_quantity(&client_order_id),
1088        )
1089        .ok()?;
1090
1091        let quantity =
1092            state.confirm_pending_reduction(&client_order_id, &order.id, active_quantity)?;
1093        Some((client_order_id, strategy_id, quantity))
1094    }
1095
1096    fn derive_fill_changes(
1097        context: &UnmatchedOrderContext<'_>,
1098        state: &mut OcmState,
1099    ) -> (Option<FillReport>, Vec<FillVoidAllocation>, bool) {
1100        let order = context.order;
1101        let price_restatement = state.fill_tracker.has_unseen_price_restatement(order);
1102        let has_applied_fill_lots = state.fill_tracker.has_fill_lots(&order.id);
1103        let size_matched = order.sm.unwrap_or(Decimal::ZERO);
1104        let size_voided = order.sv.unwrap_or(Decimal::ZERO);
1105        let gross_matched = size_matched + size_voided;
1106        let mut cumulative = order.clone();
1107
1108        cumulative.sm = Some(if has_applied_fill_lots {
1109            gross_matched
1110        } else {
1111            size_matched
1112        });
1113
1114        let fill = state.fill_tracker.maybe_fill_report(
1115            &cumulative,
1116            order.s,
1117            context.instrument_id,
1118            context.account_id,
1119            context.currency,
1120            context.ts_event,
1121            context.ts_init,
1122        );
1123
1124        if has_applied_fill_lots {
1125            return (
1126                fill,
1127                state.fill_tracker.maybe_fill_voids(order),
1128                price_restatement,
1129            );
1130        }
1131
1132        // A first-seen snapshot has no proof that Nautilus applied the voided portion.
1133        // Only anchor gross lifecycle quantity after emitting a surviving fill lot.
1134        if fill.is_some() {
1135            state.fill_tracker.sync_order(
1136                &order.id,
1137                gross_matched,
1138                order.avp.unwrap_or(Decimal::ZERO),
1139            );
1140        }
1141        state.fill_tracker.sync_voided_qty(&order.id, size_voided);
1142        (fill, Vec::new(), price_restatement)
1143    }
1144
1145    #[allow(
1146        clippy::too_many_arguments,
1147        reason = "tracked OCM routing needs resolved order, fill, and replace state"
1148    )]
1149    fn emit_tracked_order_events(
1150        context: &UnmatchedOrderContext<'_>,
1151        state: &mut OcmState,
1152        report: &OrderStatusReport,
1153        client_order_id: ClientOrderId,
1154        strategy_id: StrategyId,
1155        fill: Option<FillReport>,
1156        fill_voids: Vec<FillVoidAllocation>,
1157        cancel_action: CancelAction,
1158        price_restatement: bool,
1159    ) -> bool {
1160        if state.claim_acceptance(client_order_id, report.venue_order_id) {
1161            let accepted = OrderAccepted::new(
1162                context.emitter.trader_id(),
1163                strategy_id,
1164                context.instrument_id,
1165                client_order_id,
1166                report.venue_order_id,
1167                context.account_id,
1168                UUID4::new(),
1169                report.ts_accepted,
1170                context.ts_init,
1171                false,
1172            );
1173            context
1174                .emitter
1175                .send_order_event(OrderEventAny::Accepted(accepted));
1176        }
1177
1178        let has_fill = fill.is_some() && !price_restatement;
1179
1180        let causation_id = fill.map(|fill_report| {
1181            Self::emit_tracked_fill(context, report, client_order_id, strategy_id, &fill_report)
1182        });
1183
1184        let should_reclose = cancel_action.should_reclose_after_fill(
1185            report.order_status,
1186            has_fill,
1187            state.is_canceled_replace(&context.order.id),
1188        );
1189
1190        let reclose_before_void = should_reclose
1191            && !fill_voids.is_empty()
1192            && report.order_status == OrderStatus::Canceled;
1193
1194        if reclose_before_void {
1195            Self::emit_tracked_cancel(context, report, client_order_id, strategy_id);
1196        }
1197
1198        if !Self::emit_fill_voids(
1199            context,
1200            report,
1201            client_order_id,
1202            strategy_id,
1203            fill_voids,
1204            causation_id,
1205        ) {
1206            return false;
1207        }
1208
1209        let emit_cancel = match cancel_action {
1210            CancelAction::Emit => report.order_status == OrderStatus::Canceled,
1211            CancelAction::Suppress => false,
1212            CancelAction::RecloseAfterFill => should_reclose && !reclose_before_void,
1213        };
1214
1215        if emit_cancel {
1216            Self::emit_tracked_cancel(context, report, client_order_id, strategy_id);
1217        }
1218
1219        true
1220    }
1221
1222    fn emit_tracked_cancel(
1223        context: &UnmatchedOrderContext<'_>,
1224        report: &OrderStatusReport,
1225        client_order_id: ClientOrderId,
1226        strategy_id: StrategyId,
1227    ) {
1228        let canceled = OrderCanceled::new(
1229            context.emitter.trader_id(),
1230            strategy_id,
1231            context.instrument_id,
1232            client_order_id,
1233            UUID4::new(),
1234            report.ts_last,
1235            context.ts_init,
1236            false,
1237            Some(report.venue_order_id),
1238            Some(context.account_id),
1239            report.cancel_reason.as_deref().map(Ustr::from),
1240        );
1241        context
1242            .emitter
1243            .send_order_event(OrderEventAny::Canceled(canceled));
1244    }
1245
1246    fn emit_tracked_fill(
1247        context: &UnmatchedOrderContext<'_>,
1248        report: &OrderStatusReport,
1249        client_order_id: ClientOrderId,
1250        strategy_id: StrategyId,
1251        fill_report: &FillReport,
1252    ) -> UUID4 {
1253        log::debug!(
1254            "Fill: bet_id={}, last_qty={}, last_px={}",
1255            context.order.id,
1256            fill_report.last_qty,
1257            fill_report.last_px,
1258        );
1259        let filled = OrderFilled::new(
1260            context.emitter.trader_id(),
1261            strategy_id,
1262            context.instrument_id,
1263            client_order_id,
1264            fill_report.venue_order_id,
1265            context.account_id,
1266            fill_report.trade_id,
1267            fill_report.order_side,
1268            report.order_type,
1269            fill_report.last_qty,
1270            fill_report.last_px,
1271            context.currency,
1272            fill_report.liquidity_side,
1273            UUID4::new(),
1274            fill_report.ts_event,
1275            context.ts_init,
1276            false,
1277            fill_report.venue_position_id,
1278            Some(fill_report.commission),
1279            None,
1280        );
1281        let event_id = filled.event_id;
1282        context
1283            .emitter
1284            .send_order_event(OrderEventAny::Filled(filled));
1285        event_id
1286    }
1287
1288    fn emit_fill_voids(
1289        context: &UnmatchedOrderContext<'_>,
1290        report: &OrderStatusReport,
1291        client_order_id: ClientOrderId,
1292        strategy_id: StrategyId,
1293        fill_voids: Vec<FillVoidAllocation>,
1294        mut causation_id: Option<UUID4>,
1295    ) -> bool {
1296        if fill_voids.is_empty() {
1297            return Self::emit_terminal_fill_void(
1298                context,
1299                report,
1300                client_order_id,
1301                strategy_id,
1302                causation_id,
1303            );
1304        }
1305
1306        for allocation in fill_voids {
1307            let correction_id = Ustr::from(&format!(
1308                "{}-sv-{}-{}",
1309                context.order.id,
1310                context.order.sv.unwrap_or(Decimal::ZERO).normalize(),
1311                allocation.trade_id,
1312            ));
1313
1314            let mut fill_voided = OrderFillVoided::new(
1315                context.emitter.trader_id(),
1316                strategy_id,
1317                context.instrument_id,
1318                client_order_id,
1319                report.venue_order_id,
1320                context.account_id,
1321                correction_id,
1322                allocation.trade_id,
1323                allocation.voided_qty,
1324                None,
1325                OrderSide::from(context.order.side),
1326                report.order_type,
1327                allocation.last_px,
1328                context.currency,
1329                LiquiditySide::NoLiquiditySide,
1330                None,
1331                context.order.rc.as_deref().map(Ustr::from),
1332                None,
1333                UUID4::new(),
1334                report.ts_last,
1335                context.ts_init,
1336                false,
1337                false,
1338            );
1339
1340            fill_voided.causation_id = causation_id;
1341            causation_id = Some(fill_voided.event_id);
1342            context
1343                .emitter
1344                .send_order_event(OrderEventAny::FillVoided(fill_voided));
1345        }
1346
1347        true
1348    }
1349
1350    fn emit_terminal_fill_void(
1351        context: &UnmatchedOrderContext<'_>,
1352        report: &OrderStatusReport,
1353        client_order_id: ClientOrderId,
1354        strategy_id: StrategyId,
1355        causation_id: Option<UUID4>,
1356    ) -> bool {
1357        if report.order_status != OrderStatus::Voided {
1358            return true;
1359        }
1360        let order = context.order;
1361        let Ok(voided_qty) = parse_betfair_quantity(order.sv.unwrap_or(Decimal::ZERO)) else {
1362            log::warn!("Cannot parse voided quantity for bet_id={}", order.id);
1363            return false;
1364        };
1365        let Ok(last_px) = parse_betfair_price(order.avp.unwrap_or(order.p)) else {
1366            log::warn!("Cannot parse voided price for bet_id={}", order.id);
1367            return false;
1368        };
1369
1370        let mut voided = OrderFillVoided::new(
1371            context.emitter.trader_id(),
1372            strategy_id,
1373            context.instrument_id,
1374            client_order_id,
1375            report.venue_order_id,
1376            context.account_id,
1377            Ustr::from(&format!("{}-sv", order.id)),
1378            TradeId::new(format!("VOID-{}", order.id)),
1379            voided_qty,
1380            None,
1381            OrderSide::from(order.side),
1382            report.order_type,
1383            last_px,
1384            context.currency,
1385            LiquiditySide::NoLiquiditySide,
1386            None,
1387            order.rc.as_deref().map(Ustr::from),
1388            None,
1389            UUID4::new(),
1390            report.ts_last,
1391            context.ts_init,
1392            false,
1393            false,
1394        );
1395
1396        voided.causation_id = causation_id;
1397        context
1398            .emitter
1399            .send_order_event(OrderEventAny::FillVoided(voided));
1400        true
1401    }
1402
1403    fn emit_untracked_order_reports(
1404        context: &UnmatchedOrderContext<'_>,
1405        report: OrderStatusReport,
1406        fill: Option<FillReport>,
1407    ) {
1408        // The fill must precede the cumulative status report to avoid an inferred duplicate.
1409        if let Some(mut fill_report) = fill {
1410            fill_report.client_order_id = report.client_order_id;
1411
1412            log::debug!(
1413                "Fill: bet_id={}, last_qty={}, last_px={}",
1414                context.order.id,
1415                fill_report.last_qty,
1416                fill_report.last_px,
1417            );
1418            context.emitter.send_fill_report(fill_report);
1419        }
1420
1421        context.emitter.send_order_status_report(report);
1422    }
1423}
1424
1425#[async_trait(?Send)]
1426impl ExecutionClient for BetfairExecutionClient {
1427    fn is_connected(&self) -> bool {
1428        let connected = self.core.is_connected()
1429            && !self.reconciliation_gate.is_halted()
1430            && self
1431                .stream_client
1432                .as_ref()
1433                .is_some_and(|client| client.is_order_ready());
1434        if !connected {
1435            return false;
1436        }
1437
1438        // Drain any OCMs the network handler buffered during reconnect
1439        self.process_pending_resync();
1440        true
1441    }
1442
1443    fn client_id(&self) -> ClientId {
1444        self.core.client_id
1445    }
1446
1447    fn account_id(&self) -> AccountId {
1448        self.core.account_id
1449    }
1450
1451    fn venue(&self) -> Venue {
1452        *BETFAIR_VENUE
1453    }
1454
1455    fn oms_type(&self) -> OmsType {
1456        self.core.oms_type
1457    }
1458
1459    fn get_account(&self) -> Option<AccountAny> {
1460        self.core.cache().account_owned(&self.core.account_id)
1461    }
1462
1463    fn provides_bulk_position_coverage(&self, _instrument_id: InstrumentId) -> bool {
1464        false
1465    }
1466
1467    fn generate_account_state(
1468        &self,
1469        balances: Vec<AccountBalance>,
1470        margins: Vec<MarginBalance>,
1471        reported: bool,
1472        ts_event: UnixNanos,
1473        info: Option<Params>,
1474    ) -> anyhow::Result<()> {
1475        self.emitter
1476            .emit_account_state(balances, margins, reported, ts_event, info);
1477        Ok(())
1478    }
1479
1480    fn start(&mut self) -> anyhow::Result<()> {
1481        if self.core.is_started() {
1482            return Ok(());
1483        }
1484
1485        let sender = get_exec_event_sender();
1486        self.emitter.set_sender(sender);
1487        self.core.set_started();
1488
1489        log::info!(
1490            "Started: client_id={}, account_id={}",
1491            self.core.client_id,
1492            self.core.account_id,
1493        );
1494        Ok(())
1495    }
1496
1497    fn stop(&mut self) -> anyhow::Result<()> {
1498        if self.core.is_stopped() {
1499            return Ok(());
1500        }
1501
1502        self.core.set_stopped();
1503        self.core.set_disconnected();
1504        self.abort_session_tasks();
1505        self.abort_pending_tasks();
1506
1507        if let Some(control) = &self.socket_control {
1508            control.deregister();
1509        }
1510
1511        if let Some(client) = self.stream_client.as_ref() {
1512            client.begin_shutdown();
1513        }
1514
1515        self.clear_resync_state();
1516        log::info!("Stopped: client_id={}", self.core.client_id);
1517        Ok(())
1518    }
1519
1520    async fn connect(&mut self) -> anyhow::Result<()> {
1521        if self.core.is_connected() && self.session_tasks.is_open() && self.pending_tasks.is_open()
1522        {
1523            return Ok(());
1524        }
1525
1526        if !self.session_tasks.is_open() || !self.pending_tasks.is_open() {
1527            self.teardown_partial_connect().await?;
1528            self.session_tasks
1529                .start_generation()
1530                .map_err(|e| anyhow::anyhow!("Failed to start Betfair session generation: {e}"))?;
1531            self.pending_tasks
1532                .start_generation()
1533                .map_err(|e| anyhow::anyhow!("Failed to start Betfair task generation: {e}"))?;
1534        }
1535
1536        let http_cancellation = self.http_client.cancellation_token();
1537        let setup_guard =
1538            TaskGroupGuard::new(&[&self.session_tasks, &self.pending_tasks], move || {
1539                http_cancellation.cancel();
1540            });
1541
1542        register_betfair_custom_data();
1543
1544        let session_token_result = async {
1545            self.http_client
1546                .connect()
1547                .await
1548                .map_err(|e| anyhow::anyhow!("{e}"))?;
1549
1550            let funds: AccountFundsResponse = self
1551                .http_client
1552                .send_accounts(METHOD_GET_ACCOUNT_FUNDS, serde_json::json!({}))
1553                .await
1554                .map_err(|e| anyhow::anyhow!("{e}"))?;
1555
1556            let ts_init = self.clock.get_time_ns();
1557            let account_state = parse_account_state(
1558                &funds,
1559                self.core.account_id,
1560                self.currency,
1561                ts_init,
1562                ts_init,
1563            )?;
1564            self.emitter.send_account_state(account_state);
1565
1566            self.http_client
1567                .session_token()
1568                .await
1569                .ok_or_else(|| anyhow::anyhow!("No session token after login"))
1570        }
1571        .await;
1572        let session_token = match session_token_result {
1573            Ok(session_token) => session_token,
1574            Err(e) => {
1575                if let Err(teardown_error) = self.teardown_partial_connect().await {
1576                    return Err(e.context(format!(
1577                        "Betfair execution startup teardown failed: {teardown_error}"
1578                    )));
1579                }
1580                return Err(e);
1581            }
1582        };
1583
1584        // Sync OCM state from cached orders before stream connects
1585        self.sync_ocm_state_from_cache();
1586
1587        let market_ids_filter = self
1588            .config
1589            .stream_market_ids_filter
1590            .as_ref()
1591            .map(|ids| ids.iter().cloned().collect::<ahash::AHashSet<String>>());
1592
1593        let (reconnect_tx, mut reconnect_rx) = tokio::sync::mpsc::unbounded_channel();
1594        let queued_generation = Arc::new(AtomicU64::new(0));
1595        let (account_refresh_tx, mut account_refresh_rx) = tokio::sync::mpsc::unbounded_channel();
1596        self.account_refresh_tx = Some(account_refresh_tx.clone());
1597
1598        let handler = Self::create_ocm_handler(
1599            self.emitter.clone(),
1600            self.core.account_id,
1601            self.currency,
1602            Arc::clone(&self.ocm_state),
1603            get_data_event_sender(),
1604            market_ids_filter,
1605            self.config.ignore_external_orders,
1606            reconnect_tx,
1607            queued_generation,
1608            Arc::clone(&self.pending_resync),
1609            Arc::clone(&self.reconciliation_gate),
1610            Arc::clone(&self.replay_buffer),
1611            account_refresh_tx,
1612            self.clock,
1613        );
1614
1615        let transport_gate = Arc::clone(&self.reconciliation_gate);
1616        let transport_pending_resync = Arc::clone(&self.pending_resync);
1617        let transport_was_connected = Arc::new(AtomicBool::new(false));
1618        let halt_on_disconnect = move |state| match state {
1619            SocketState::Connected => {
1620                transport_was_connected.store(true, Ordering::Release);
1621            }
1622            SocketState::Disconnected => {
1623                if transport_was_connected.swap(false, Ordering::AcqRel) {
1624                    transport_gate.halt();
1625                    transport_pending_resync.store(true, Ordering::Release);
1626                }
1627            }
1628        };
1629        let state_sink = match self.socket_control.as_ref() {
1630            Some(control) => control.sink_with(halt_on_disconnect),
1631            None => SocketStateSink::new(halt_on_disconnect),
1632        };
1633
1634        let stream_client_result = BetfairStreamClient::connect_with_state_sink(
1635            &self.credential,
1636            session_token,
1637            handler,
1638            self.stream_config.clone(),
1639            HeartbeatTimeoutSource::Server,
1640            Some(state_sink),
1641        )
1642        .await;
1643        let stream_client = match stream_client_result {
1644            Ok(stream_client) => stream_client,
1645            Err(e) => {
1646                let e = anyhow::Error::new(e);
1647                if let Err(teardown_error) = self.teardown_partial_connect().await {
1648                    return Err(e.context(format!(
1649                        "Betfair execution startup teardown failed: {teardown_error}"
1650                    )));
1651                }
1652                return Err(e);
1653            }
1654        };
1655
1656        let stream_client = Arc::new(stream_client);
1657
1658        if let Err(e) = stream_client.subscribe_orders(None, None).await {
1659            if let Err(close_error) = stream_client.close().await {
1660                log::warn!(
1661                    "Failed to close Betfair order stream after subscribe failure: {close_error}"
1662                );
1663            }
1664            let e = anyhow::Error::new(e);
1665            if let Err(teardown_error) = self.teardown_partial_connect().await {
1666                return Err(e.context(format!(
1667                    "Betfair execution startup teardown failed: {teardown_error}"
1668                )));
1669            }
1670            return Err(e);
1671        }
1672
1673        self.stream_client = Some(Arc::clone(&stream_client));
1674        setup_guard.disarm();
1675        let http_cancellation = self.http_client.cancellation_token();
1676        let shutdown_stream = Arc::clone(&stream_client);
1677        let stream_guard =
1678            TaskGroupGuard::new(&[&self.session_tasks, &self.pending_tasks], move || {
1679                http_cancellation.cancel();
1680                shutdown_stream.begin_shutdown();
1681            });
1682
1683        let session_result = async {
1684
1685        // Spawn periodic keep-alive to prevent session expiry
1686        let keep_alive_client = Arc::clone(&self.http_client);
1687        let keep_alive_stream = Arc::clone(&stream_client);
1688        let keep_alive_app_key = self.credential.app_key().to_string();
1689
1690        self.session_tasks.spawn(async move {
1691            const KEEP_ALIVE_INTERVAL_SECS: u64 = 36_000;
1692            let interval = tokio::time::Duration::from_secs(KEEP_ALIVE_INTERVAL_SECS);
1693            loop {
1694                tokio::time::sleep(interval).await;
1695
1696                let (_, session_replaced) = match keep_alive_client.keep_alive_with_token().await {
1697                    Ok(token) => (token, false),
1698                    Err(ref e) if e.is_login_failed() => {
1699                        log::warn!("Betfair execution session expired, attempting re-login: {e}");
1700
1701                        match keep_alive_client.reconnect_with_token().await {
1702                            Ok(token) => (token, true),
1703                            Err(e) => {
1704                                log::warn!("Betfair execution re-login failed: {e}");
1705                                continue;
1706                            }
1707                        }
1708                    }
1709                    Err(e) => {
1710                        log::warn!("Betfair execution keep-alive failed (transient): {e}");
1711                        continue;
1712                    }
1713                };
1714                apply_stream_session_refresh(
1715                    keep_alive_client.as_ref(),
1716                    Some(&keep_alive_stream),
1717                    &keep_alive_app_key,
1718                    SessionRefresh {
1719                        refreshed: true,
1720                        replaced: session_replaced,
1721                    },
1722                )
1723                .await;
1724                log::debug!("Betfair execution session keep-alive sent");
1725            }
1726        })?;
1727
1728        let acct_client = Arc::clone(&self.http_client);
1729        let acct_emitter = self.emitter.clone();
1730        let acct_id = self.core.account_id;
1731        let acct_currency = self.currency;
1732        let acct_clock = self.clock;
1733        let periodic_interval = (self.config.calculate_account_state
1734            && self.config.request_account_state_secs > 0)
1735            .then(|| tokio::time::Duration::from_secs(self.config.request_account_state_secs));
1736
1737        self.session_tasks.spawn(async move {
1738            loop {
1739                let should_refresh = if let Some(interval) = periodic_interval {
1740                    tokio::select! {
1741                        request = account_refresh_rx.recv() => request.is_some(),
1742                        () = tokio::time::sleep(interval) => true,
1743                    }
1744                } else {
1745                    account_refresh_rx.recv().await.is_some()
1746                };
1747
1748                if !should_refresh {
1749                    return;
1750                }
1751
1752                while account_refresh_rx.try_recv().is_ok() {}
1753
1754                match acct_client
1755                    .send_accounts::<AccountFundsResponse, _>(
1756                        METHOD_GET_ACCOUNT_FUNDS,
1757                        serde_json::json!({}),
1758                    )
1759                    .await
1760                {
1761                    Ok(funds) => {
1762                        let ts_init = acct_clock.get_time_ns();
1763
1764                        match parse_account_state(&funds, acct_id, acct_currency, ts_init, ts_init)
1765                        {
1766                            Ok(state) => acct_emitter.send_account_state(state),
1767                            Err(e) => log::warn!("Failed to parse account state: {e}"),
1768                        }
1769                    }
1770                    Err(e) => log::warn!("Failed to fetch account state: {e}"),
1771                }
1772            }
1773        })?;
1774
1775        let reconnect_http = Arc::clone(&self.http_client);
1776        let reconnect_stream = Arc::clone(&stream_client);
1777        let reconnect_emitter = self.emitter.clone();
1778        let reconnect_app_key = self.credential.app_key().to_string();
1779        let reconnect_clock = self.clock;
1780        let reconnect_client_id = self.core.client_id;
1781        let reconnect_acct_id = self.core.account_id;
1782        let reconnect_currency = self.currency;
1783        let reconnect_market_ids = self.reconcile_market_ids();
1784        let reconnect_lookback_mins = self.config.stream_gap_recovery_lookback_mins;
1785        let reconnect_ocm_state = Arc::clone(&self.ocm_state);
1786        let reconnect_gate = Arc::clone(&self.reconciliation_gate);
1787
1788        self.session_tasks.spawn(async move {
1789            const RECOVERY_ATTEMPTS: usize = 4;
1790
1791            while let Some(generation) = reconnect_rx.recv().await {
1792                log::info!("Handling execution stream reconnection");
1793                let mut state_rx = reconnect_gate.subscribe();
1794
1795                for attempt in 0..RECOVERY_ATTEMPTS {
1796                    if !reconnect_gate.is_current(generation) {
1797                        break;
1798                    }
1799
1800                    let recovery = tokio::select! {
1801                        result = attempt_post_reconnect_recovery(
1802                        &reconnect_http,
1803                        &reconnect_stream,
1804                        &reconnect_app_key,
1805                        reconnect_client_id,
1806                        reconnect_acct_id,
1807                        reconnect_currency,
1808                        reconnect_clock,
1809                        reconnect_market_ids.clone(),
1810                        reconnect_lookback_mins,
1811                        &reconnect_ocm_state,
1812                        ) => Some(result),
1813                        () = wait_for_generation_change(&mut state_rx, generation) => None,
1814                    };
1815                    let Some(recovery) = recovery else {
1816                        break;
1817                    };
1818
1819                    match recovery {
1820                        Ok(recovery) => {
1821                            let committed = commit_post_reconnect_mass_status(
1822                                &reconnect_gate,
1823                                generation,
1824                                &reconnect_ocm_state,
1825                                &reconnect_emitter,
1826                                recovery,
1827                            );
1828
1829                            match committed {
1830                                Ok(Some((order_count, fill_count, account_state))) => {
1831                                    if let Some(account_state) = account_state {
1832                                        reconnect_emitter.send_account_state(account_state);
1833                                    }
1834                                    log::info!(
1835                                        "Post-reconnect reconciliation submitted: \
1836                                        orders={order_count}, fills={fill_count}",
1837                                    );
1838                                }
1839                                Ok(None) => log::info!(
1840                                    "A newer execution stream reconnect remains unreconciled",
1841                                ),
1842                                Err(e) => log::warn!(
1843                                    "Post-reconnect reconciliation publication failed: {e}",
1844                                ),
1845                            }
1846                            break;
1847                        }
1848                        Err(e) => {
1849                            let attempt_number = attempt + 1;
1850                            log::warn!(
1851                                "Post-reconnect reconciliation attempt \
1852                                 {attempt_number}/{RECOVERY_ATTEMPTS} failed: {e}",
1853                            );
1854
1855                            if attempt_number == RECOVERY_ATTEMPTS {
1856                                log::warn!(
1857                                    "Post-reconnect reconciliation exhausted retries; \
1858                                     submissions remain halted",
1859                                );
1860                                break;
1861                            }
1862
1863                            let delay_ms = 250_u64.saturating_mul(1_u64 << attempt);
1864                            tokio::select! {
1865                                () = tokio::time::sleep(tokio::time::Duration::from_millis(delay_ms)) => {}
1866                                () = wait_for_generation_change(&mut state_rx, generation) => break,
1867                            }
1868                        }
1869                    }
1870                }
1871            }
1872        })?;
1873
1874        Ok::<(), anyhow::Error>(())
1875        }
1876        .await;
1877
1878        if let Err(e) = session_result {
1879            if let Err(teardown_error) = self.teardown_partial_connect().await {
1880                return Err(e.context(format!(
1881                    "Betfair execution startup teardown failed: {teardown_error}"
1882                )));
1883            }
1884            return Err(e);
1885        }
1886
1887        if let Some(control) = &self.socket_control {
1888            let reconnect_stream = Arc::clone(&stream_client);
1889            control.register(move || reconnect_stream.request_reconnect_outcome());
1890        }
1891
1892        self.core.set_connected();
1893        stream_guard.disarm();
1894
1895        log::info!("Connected: client_id={}", self.core.client_id);
1896        Ok(())
1897    }
1898
1899    async fn disconnect(&mut self) -> anyhow::Result<()> {
1900        self.teardown_partial_connect().await?;
1901
1902        log::info!("Disconnected: client_id={}", self.core.client_id);
1903        Ok(())
1904    }
1905
1906    fn query_order(&self, cmd: QueryOrder) -> anyhow::Result<()> {
1907        self.process_pending_resync();
1908
1909        let http_client = Arc::clone(&self.http_client);
1910        let emitter = self.emitter.clone();
1911        let account_id = self.core.account_id;
1912        let ocm_state = Arc::clone(&self.ocm_state);
1913        let clock = self.clock;
1914        let client_order_id = cmd.client_order_id;
1915        let venue_order_id = cmd.venue_order_id;
1916        let instrument_id = cmd.instrument_id;
1917        let stream_client = self.stream_client.as_ref().map(Arc::clone);
1918        let app_key = self.credential.app_key().to_string();
1919
1920        self.spawn_task("query_order", async move {
1921            let mut session_refresh = SessionRefresh::default();
1922            let stream_session = StreamSession {
1923                client: stream_client.as_ref(),
1924                app_key: &app_key,
1925            };
1926            let mut candidates: Vec<CurrentOrderSummary> = Vec::new();
1927            let mut seen_bet_ids: AHashSet<String> = AHashSet::new();
1928
1929            // Customer_order_ref lookup: Betfair reuses the ref across a
1930            // replace (old bet cancelled + new bet live), so this returns the
1931            // live replacement even when the cached bet_id is stale.
1932            let rfo = make_customer_order_ref(client_order_id.as_str());
1933            let rfo_params = list_current_orders_filter_ref(rfo.clone());
1934
1935            match list_current_orders_with_retry(
1936                &http_client,
1937                &rfo_params,
1938                stream_session,
1939                &mut session_refresh,
1940            )
1941            .await
1942            {
1943                Ok(r) => extend_unique(&mut candidates, &mut seen_bet_ids, r.current_orders),
1944                Err(e) => log::warn!("Betfair query_order ref lookup failed: {e}"),
1945            }
1946
1947            if candidates.is_empty() {
1948                let rfo_legacy = make_customer_order_ref_legacy(client_order_id.as_str());
1949                if rfo_legacy != rfo {
1950                    let legacy_params = list_current_orders_filter_ref(rfo_legacy);
1951
1952                    match list_current_orders_with_retry(
1953                        &http_client,
1954                        &legacy_params,
1955                        stream_session,
1956                        &mut session_refresh,
1957                    )
1958                    .await
1959                    {
1960                        Ok(r) => {
1961                            extend_unique(&mut candidates, &mut seen_bet_ids, r.current_orders);
1962                        }
1963                        Err(e) => log::warn!("Betfair query_order legacy lookup failed: {e}"),
1964                    }
1965                }
1966            }
1967
1968            // Always also query by bet_id when known. This rescues
1969            // pre-existing orders without a recognizable ref and orders whose
1970            // ref-based results came back as foreign-market collisions only.
1971            if let Some(ref bet_id) = venue_order_id {
1972                let params = list_current_orders_filter_bet_id(bet_id.to_string());
1973
1974                match list_current_orders_with_retry(
1975                    &http_client,
1976                    &params,
1977                    stream_session,
1978                    &mut session_refresh,
1979                )
1980                .await
1981                {
1982                    Ok(r) => extend_unique(&mut candidates, &mut seen_bet_ids, r.current_orders),
1983                    Err(e) => log::warn!("Betfair query_order bet_id lookup failed: {e}"),
1984                }
1985            }
1986
1987            let order = if candidates.is_empty() {
1988                log::warn!(
1989                    "Betfair query_order found no order for client_order_id={client_order_id}, venue_order_id={venue_order_id:?}",
1990                );
1991                None
1992            } else {
1993                select_order_for_query(
1994                    &candidates,
1995                    instrument_id,
1996                    client_order_id,
1997                    venue_order_id,
1998                )
1999            };
2000
2001            if let Some(order) = order {
2002                let ts_init = clock.get_time_ns();
2003                match parse_current_order_report(order, account_id, ts_init) {
2004                    Ok(mut report) => {
2005                        let update = {
2006                            let mut state = ocm_state.lock();
2007                            let update = resolve_query_order_report(
2008                                order,
2009                                &mut report,
2010                                client_order_id,
2011                                &mut state,
2012                                &emitter,
2013                            );
2014
2015                            let replaced_fills =
2016                                replaced_leg_fills_from_candidates(&candidates, order, &state);
2017                            let reduced_quantity = state.reduced_quantity(&order.bet_id);
2018                            if let Some(quantity) = reduced_quantity {
2019                                report.quantity = quantity;
2020                            } else if let Some(OrderEventAny::Updated(updated)) = &update {
2021                                report.quantity = updated.quantity;
2022                            }
2023
2024                            replaced_fills.fold(
2025                                &mut report,
2026                                reduced_quantity.is_some() || update.is_some(),
2027                            );
2028
2029                            update
2030                        };
2031
2032                        if let Some(update) = update {
2033                            emitter.send_order_event(update);
2034                        }
2035                        emitter.send_order_status_report(report);
2036                    }
2037                    Err(e) => {
2038                        log::warn!("Failed to parse order report for {}: {e}", order.bet_id);
2039                    }
2040                }
2041            }
2042
2043            apply_stream_session_refresh(
2044                http_client.as_ref(),
2045                stream_client.as_ref(),
2046                &app_key,
2047                session_refresh,
2048            )
2049            .await;
2050            Ok(())
2051        });
2052
2053        Ok(())
2054    }
2055
2056    async fn generate_mass_status(
2057        &self,
2058        lookback_mins: Option<u64>,
2059    ) -> anyhow::Result<Option<ExecutionMassStatus>> {
2060        self.process_pending_resync();
2061
2062        log::info!("Generating ExecutionMassStatus (lookback_mins={lookback_mins:?})");
2063
2064        let ts_now = self.clock.get_time_ns();
2065        let start = lookback_mins
2066            .map(DurationNanos::try_from_mins)
2067            .transpose()?
2068            .map(|lookback| ts_now.saturating_sub(lookback));
2069
2070        let mut session_refresh = SessionRefresh::default();
2071
2072        let fetched = fetch_order_status_reports_snapshot_http(
2073            &self.http_client,
2074            self.core.account_id,
2075            ts_now,
2076            self.reconcile_market_ids(),
2077            false,
2078            &self.ocm_state,
2079            StreamSession {
2080                client: self.stream_client.as_ref(),
2081                app_key: self.credential.app_key(),
2082            },
2083            &mut session_refresh,
2084        )
2085        .await;
2086
2087        apply_stream_session_refresh(
2088            self.http_client.as_ref(),
2089            self.stream_client.as_ref(),
2090            self.credential.app_key(),
2091            session_refresh,
2092        )
2093        .await;
2094
2095        let mut fetched = fetched?;
2096        assign_report_owners(&mut fetched.reports, &self.ocm_state.lock());
2097        retain_snapshot_fill_orders(&mut fetched.orders, start, None)?;
2098
2099        let snapshot = MassStatusSnapshot {
2100            client_id: self.core.client_id,
2101            account_id: self.core.account_id,
2102            currency: self.currency,
2103            ts_init: ts_now,
2104            order_reports: fetched.reports,
2105            active_quantities: fetched.active_quantities,
2106            voided_quantities: fetched.voided_quantities,
2107            fill_orders: fetched.orders,
2108            account_state: None,
2109        };
2110
2111        let mut state = self.ocm_state.lock();
2112        let mut staged_state = state.clone();
2113        let (mass_status, updates) = snapshot.build(&mut staged_state, &self.emitter)?;
2114
2115        log::info!(
2116            "Received {} OrderStatusReports",
2117            mass_status.order_reports().len()
2118        );
2119        log::info!(
2120            "Received {} FillReports",
2121            mass_status
2122                .fill_reports()
2123                .values()
2124                .map(Vec::len)
2125                .sum::<usize>(),
2126        );
2127
2128        for update in updates {
2129            self.emitter.try_send_order_event(update)?;
2130        }
2131
2132        // No await after commit: cancellation must not consume undelivered fills
2133        *state = staged_state;
2134        Ok(Some(mass_status))
2135    }
2136
2137    fn generate_order_status_reports_task(
2138        &self,
2139        cmd: &GenerateOrderStatusReports,
2140    ) -> Option<ExecutionReportTask<Vec<OrderStatusReport>>> {
2141        self.process_pending_resync();
2142
2143        let http_client = Arc::clone(&self.http_client);
2144        let stream_client = self.stream_client.clone();
2145        let app_key = self.credential.app_key().to_string();
2146        let account_id = self.core.account_id;
2147        let ts_init = self.clock.get_time_ns();
2148        let market_ids = self.reconcile_market_ids();
2149        let collection_state = Arc::clone(&self.ocm_state);
2150        let state = Arc::clone(&self.ocm_state);
2151        let emitter = self.emitter.clone();
2152        let command = cmd.clone();
2153        let filter = cmd.clone();
2154
2155        Some(ExecutionReportTask::new(
2156            async move {
2157                let mut session_refresh = SessionRefresh::default();
2158
2159                let result = collect_order_status_reports_http(
2160                    &http_client,
2161                    account_id,
2162                    ts_init,
2163                    market_ids,
2164                    Some(&command),
2165                    &collection_state,
2166                    StreamSession {
2167                        client: stream_client.as_ref(),
2168                        app_key: &app_key,
2169                    },
2170                    &mut session_refresh,
2171                )
2172                .await;
2173
2174                apply_stream_session_refresh(
2175                    &http_client,
2176                    stream_client.as_ref(),
2177                    &app_key,
2178                    session_refresh,
2179                )
2180                .await;
2181                result
2182            },
2183            move |fetched| {
2184                let reports = finish_order_status_reports(
2185                    fetched,
2186                    Some(&filter),
2187                    &state,
2188                    Some(&emitter),
2189                    true,
2190                );
2191                log::debug!("Generated {} order status reports", reports.len());
2192                Ok(reports)
2193            },
2194        ))
2195    }
2196
2197    fn generate_fill_reports_task(
2198        &self,
2199        cmd: &GenerateFillReports,
2200    ) -> Option<ExecutionReportTask<Vec<FillReport>>> {
2201        self.process_pending_resync();
2202
2203        let http_client = Arc::clone(&self.http_client);
2204        let stream_client = self.stream_client.clone();
2205        let app_key = self.credential.app_key().to_string();
2206        let account_id = self.core.account_id;
2207        let currency = self.currency;
2208        let ts_init = self.clock.get_time_ns();
2209        let market_ids = self.reconcile_market_ids();
2210        let state = Arc::clone(&self.ocm_state);
2211        let command = cmd.clone();
2212
2213        Some(ExecutionReportTask::new(
2214            async move {
2215                let date_range = fill_report_date_range(&command);
2216                let mut session_refresh = SessionRefresh::default();
2217
2218                let result = fetch_fill_orders_http(
2219                    &http_client,
2220                    market_ids,
2221                    date_range,
2222                    StreamSession {
2223                        client: stream_client.as_ref(),
2224                        app_key: &app_key,
2225                    },
2226                    &mut session_refresh,
2227                )
2228                .await;
2229
2230                apply_stream_session_refresh(
2231                    &http_client,
2232                    stream_client.as_ref(),
2233                    &app_key,
2234                    session_refresh,
2235                )
2236                .await;
2237                let mut orders = result?;
2238                retain_fill_orders(&mut orders, &command);
2239                Ok(orders)
2240            },
2241            move |orders| {
2242                let reports = finish_fill_reports(&orders, &state, account_id, currency, ts_init)?;
2243                log::debug!("Generated {} fill reports", reports.len());
2244                Ok(reports)
2245            },
2246        ))
2247    }
2248
2249    async fn generate_order_status_report(
2250        &self,
2251        _cmd: &GenerateOrderStatusReport,
2252    ) -> anyhow::Result<Option<OrderStatusReport>> {
2253        anyhow::bail!("Betfair single-order status reports are not supported")
2254    }
2255
2256    async fn generate_position_status_reports(
2257        &self,
2258        _cmd: &GeneratePositionStatusReports,
2259    ) -> anyhow::Result<Vec<PositionStatusReport>> {
2260        anyhow::bail!("Betfair position status reports are not supported")
2261    }
2262
2263    async fn generate_order_status_reports(
2264        &self,
2265        cmd: &GenerateOrderStatusReports,
2266    ) -> anyhow::Result<Vec<OrderStatusReport>> {
2267        self.process_pending_resync();
2268
2269        let mut session_refresh = SessionRefresh::default();
2270        let stream_session = StreamSession {
2271            client: self.stream_client.as_ref(),
2272            app_key: self.credential.app_key(),
2273        };
2274        let result = fetch_order_status_reports_http(
2275            &self.http_client,
2276            self.core.account_id,
2277            self.clock.get_time_ns(),
2278            self.reconcile_market_ids(),
2279            Some(cmd),
2280            &self.ocm_state,
2281            Some(&self.emitter),
2282            stream_session,
2283            &mut session_refresh,
2284        )
2285        .await;
2286
2287        apply_stream_session_refresh(
2288            self.http_client.as_ref(),
2289            self.stream_client.as_ref(),
2290            self.credential.app_key(),
2291            session_refresh,
2292        )
2293        .await;
2294        let reports = result?;
2295
2296        log::debug!("Generated {} order status reports", reports.len());
2297        Ok(reports)
2298    }
2299
2300    async fn generate_fill_reports(
2301        &self,
2302        cmd: GenerateFillReports,
2303    ) -> anyhow::Result<Vec<FillReport>> {
2304        self.process_pending_resync();
2305
2306        let date_range = fill_report_date_range(&cmd);
2307
2308        let mut session_refresh = SessionRefresh::default();
2309        let stream_session = StreamSession {
2310            client: self.stream_client.as_ref(),
2311            app_key: self.credential.app_key(),
2312        };
2313        let result = fetch_fill_reports_http(
2314            &self.http_client,
2315            self.core.account_id,
2316            self.currency,
2317            self.clock.get_time_ns(),
2318            self.reconcile_market_ids(),
2319            date_range,
2320            Some(&cmd),
2321            &self.ocm_state,
2322            stream_session,
2323            &mut session_refresh,
2324        )
2325        .await;
2326
2327        apply_stream_session_refresh(
2328            self.http_client.as_ref(),
2329            self.stream_client.as_ref(),
2330            self.credential.app_key(),
2331            session_refresh,
2332        )
2333        .await;
2334        let reports = result?;
2335
2336        log::debug!("Generated {} fill reports", reports.len());
2337        Ok(reports)
2338    }
2339
2340    fn submit_order(&self, cmd: SubmitOrder) -> anyhow::Result<()> {
2341        self.process_pending_resync();
2342
2343        let order = self.core.get_order(&cmd.client_order_id)?;
2344
2345        if let Err(reason) = validate_order(&order) {
2346            self.emitter.emit_order_denied(&order, &reason.to_string());
2347            return Ok(());
2348        }
2349
2350        if self.submissions_halted() {
2351            log::warn!(
2352                "Halting submit for {} while the execution stream is unavailable or reconciling",
2353                order.client_order_id(),
2354            );
2355            self.emitter
2356                .emit_order_denied(&order, &OrderDeniedReason::StreamReconciling.to_string());
2357            return Ok(());
2358        }
2359
2360        if order.is_closed() {
2361            log::warn!("Cannot submit closed order {}", order.client_order_id());
2362            return Ok(());
2363        }
2364
2365        let instrument_id = order.instrument_id();
2366        let market_id = extract_market_id(&instrument_id)?;
2367        let (selection_id, handicap) = extract_selection_id(&instrument_id)?;
2368
2369        let instruction = create_place_instruction(&order, selection_id, handicap)?;
2370        let collision = self
2371            .ocm_state
2372            .lock()
2373            .register_submission(order.client_order_id(), order.strategy_id())
2374            .err();
2375
2376        if let Some(customer_order_ref) = collision {
2377            let reason = customer_order_ref_collision_reason(&customer_order_ref);
2378            log::warn!("Denying submit for {}: {reason}", order.client_order_id(),);
2379            self.emitter.emit_order_denied(&order, &reason);
2380            return Ok(());
2381        }
2382
2383        let market_version = self.get_market_version(&instrument_id);
2384
2385        let params = PlaceOrdersParams {
2386            market_id,
2387            instructions: vec![instruction],
2388            customer_ref: Some(order_customer_ref()),
2389            market_version,
2390            customer_strategy_ref: None,
2391        };
2392
2393        let client_order_id = order.client_order_id();
2394        let strategy_id = order.strategy_id();
2395
2396        log::debug!("OrderSubmitted client_order_id={client_order_id}");
2397        self.emitter.emit_order_submitted(&order);
2398
2399        let http_client = Arc::clone(&self.http_client);
2400        let emitter = self.emitter.clone();
2401        let clock = self.clock;
2402        let ocm_state = Arc::clone(&self.ocm_state);
2403
2404        self.spawn_task("submit-order", async move {
2405            let report: PlaceExecutionReport = match http_client
2406                .send_betting_order(METHOD_PLACE_ORDERS, &params)
2407                .await
2408            {
2409                Ok(r) => r,
2410                Err(e) => {
2411                    match classify_http_error(&e) {
2412                        CommandFailure::Ambiguous(_) => log::warn!(
2413                            "Ambiguous submit response for {client_order_id}: {e}. \
2414                             Order may be live, awaiting OCM reconciliation",
2415                        ),
2416                        CommandFailure::NotSent(_) | CommandFailure::VenueRejected(_) => {
2417                            let reason = format!("submit-order error: {e}");
2418                            emit_http_reject_if_unreported(
2419                                &ocm_state,
2420                                &client_order_id,
2421                                &reason,
2422                                || {
2423                                    let ts_event = clock.get_time_ns();
2424                                    emitter.emit_order_rejected_event(
2425                                        strategy_id,
2426                                        instrument_id,
2427                                        client_order_id,
2428                                        &reason,
2429                                        ts_event,
2430                                        false,
2431                                    );
2432                                },
2433                            );
2434                        }
2435                    }
2436                    return Ok(());
2437                }
2438            };
2439
2440            let instruction_report =
2441                single_instruction_report(report.instruction_reports.as_deref());
2442            let instruction_result = instruction_report.map(|ir| {
2443                classify_instruction_report(ir.status, ir.error_code, false, || {
2444                    format_place_instruction_reason(ir, &report)
2445                })
2446            });
2447            let result = classify_execution_report(
2448                report.status,
2449                report.error_code,
2450                instruction_result,
2451                || format_betfair_reason(report.error_code, None, "unknown error"),
2452            );
2453
2454            match result {
2455                Err(CommandFailure::Ambiguous(_)) => {
2456                    log::warn!(
2457                        "Ambiguous submit report for {client_order_id}. \
2458                     Order may be live, awaiting OCM reconciliation",
2459                    );
2460                }
2461                Err(CommandFailure::NotSent(reason) | CommandFailure::VenueRejected(reason)) => {
2462                    emit_http_reject_if_unreported(&ocm_state, &client_order_id, &reason, || {
2463                        let ts_event = clock.get_time_ns();
2464                        emitter.emit_order_rejected_event(
2465                            strategy_id,
2466                            instrument_id,
2467                            client_order_id,
2468                            &reason,
2469                            ts_event,
2470                            false,
2471                        );
2472                    });
2473                }
2474                Ok(()) => {
2475                    if let Some(bet_id) = instruction_report.and_then(|ir| ir.bet_id.as_ref()) {
2476                        let venue_order_id = VenueOrderId::from(bet_id.as_str());
2477                        let ts_event = clock.get_time_ns();
2478
2479                        emit_http_accept_if_claimed(
2480                            &ocm_state,
2481                            &client_order_id,
2482                            venue_order_id,
2483                            || emitter.emit_order_accepted(&order, venue_order_id, ts_event),
2484                        );
2485                    } else {
2486                        log::warn!(
2487                            "Submit succeeded without a bet ID for {client_order_id}; \
2488                             awaiting OCM reconciliation",
2489                        );
2490                    }
2491                }
2492            }
2493
2494            Ok(())
2495        });
2496
2497        Ok(())
2498    }
2499
2500    fn cancel_order(&self, cmd: CancelOrder) -> anyhow::Result<()> {
2501        self.process_pending_resync();
2502
2503        let instrument_id = cmd.instrument_id;
2504        let venue_order_id = match cmd.venue_order_id {
2505            Some(venue_order_id) => venue_order_id,
2506            None => {
2507                log::warn!(
2508                    "Cannot cancel order {}: no venue_order_id",
2509                    cmd.client_order_id
2510                );
2511                return Ok(());
2512            }
2513        };
2514        let market_id = match extract_market_id(&instrument_id) {
2515            Ok(market_id) => market_id,
2516            Err(e) => {
2517                log::warn!("Cannot cancel order {}: {e}", cmd.client_order_id);
2518                return Ok(());
2519            }
2520        };
2521        let bet_id: BetId = venue_order_id.to_string();
2522
2523        let params = CancelOrdersParams {
2524            market_id: Some(market_id),
2525            instructions: Some(vec![CancelInstruction {
2526                bet_id,
2527                size_reduction: None,
2528            }]),
2529            customer_ref: Some(order_customer_ref()),
2530        };
2531
2532        let client_order_id = cmd.client_order_id;
2533        let strategy_id = cmd.strategy_id;
2534        let http_client = Arc::clone(&self.http_client);
2535        let emitter = self.emitter.clone();
2536        let ocm_state = Arc::clone(&self.ocm_state);
2537        let clock = self.clock;
2538        let sp_bet = self
2539            .core
2540            .cache()
2541            .order(&client_order_id)
2542            .is_some_and(|order| is_sp_order(&order));
2543
2544        self.spawn_task("cancel-order", async move {
2545            let result: Result<CancelExecutionReport, _> = http_client
2546                .send_betting_order(METHOD_CANCEL_ORDERS, &params)
2547                .await;
2548
2549            let report = match result {
2550                Ok(r) => r,
2551                Err(e) => {
2552                    match classify_http_error(&e) {
2553                        CommandFailure::Ambiguous(_) => log::warn!(
2554                            "Ambiguous cancel response for {client_order_id}, awaiting OCM reconciliation: {e}",
2555                        ),
2556                        CommandFailure::NotSent(_) => {
2557                            let reason = format!("cancel-order error: {e}");
2558                            let ts_event = clock.get_time_ns();
2559                            emitter.emit_order_cancel_denied_event(
2560                                strategy_id,
2561                                instrument_id,
2562                                client_order_id,
2563                                Some(venue_order_id),
2564                                &reason,
2565                                ts_event,
2566                                Some(cmd.command_id),
2567                            );
2568                        }
2569                        CommandFailure::VenueRejected(_) => {
2570                            let reason = format!("cancel-order error: {e}");
2571                            let ts_event = clock.get_time_ns();
2572                            emitter.emit_order_cancel_rejected_event(
2573                                strategy_id,
2574                                instrument_id,
2575                                client_order_id,
2576                                Some(venue_order_id),
2577                                &reason,
2578                                ts_event,
2579                                Some(cmd.command_id),
2580                            );
2581                        }
2582                    }
2583                    return Ok(());
2584                }
2585            };
2586
2587            let instruction_report =
2588                single_instruction_report(report.instruction_reports.as_deref());
2589            let instruction_result = instruction_report.map(|ir| {
2590                classify_instruction_report(ir.status, ir.error_code, !sp_bet, || {
2591                    format_cancel_instruction_reason(ir.error_code, report.error_code)
2592                })
2593            });
2594            let result = classify_execution_report(
2595                report.status,
2596                report.error_code,
2597                instruction_result,
2598                || {
2599                    format_betfair_reason(report.error_code, None, "unknown error")
2600                },
2601            );
2602
2603            match result {
2604                Ok(()) => {
2605                    let bet_taken_or_lapsed = instruction_report.is_some_and(|ir| {
2606                        ir.error_code == Some(InstructionReportErrorCode::BetTakenOrLapsed)
2607                    });
2608
2609                    if bet_taken_or_lapsed {
2610                        log::debug!(
2611                            "Cancel {client_order_id}: BetTakenOrLapsed, treating as success",
2612                        );
2613                    }
2614
2615                    let old_terminal = {
2616                        let mut state = ocm_state.lock();
2617                        let old_terminal = state
2618                            .terminal_orders
2619                            .contains(venue_order_id.as_str());
2620                        let pending =
2621                            state.take_pending_replace(client_order_id, venue_order_id.as_str());
2622                        if pending.is_some() && old_terminal {
2623                            state.retain_terminal_order(
2624                                client_order_id,
2625                                venue_order_id.as_str(),
2626                            );
2627                        }
2628                        pending.is_some_and(|_| old_terminal)
2629                    };
2630
2631                    if old_terminal {
2632                        let ts_event = clock.get_time_ns();
2633                        let canceled = OrderCanceled::new(
2634                            emitter.trader_id(),
2635                            strategy_id,
2636                            instrument_id,
2637                            client_order_id,
2638                            UUID4::new(),
2639                            ts_event,
2640                            ts_event,
2641                            false,
2642                            Some(venue_order_id),
2643                            Some(emitter.account_id()),
2644                            None,
2645                        );
2646                        emitter.send_order_event(OrderEventAny::Canceled(canceled));
2647                    }
2648                }
2649                Err(CommandFailure::Ambiguous(_)) => log::warn!(
2650                    "Ambiguous cancel report for {client_order_id}, awaiting OCM reconciliation",
2651                ),
2652                Err(CommandFailure::NotSent(reason)) => {
2653                    let ts_event = clock.get_time_ns();
2654                    emitter.emit_order_cancel_denied_event(
2655                        strategy_id,
2656                        instrument_id,
2657                        client_order_id,
2658                        Some(venue_order_id),
2659                        &reason,
2660                        ts_event,
2661                        Some(cmd.command_id),
2662                    );
2663                }
2664                Err(CommandFailure::VenueRejected(reason)) => {
2665                    let ts_event = clock.get_time_ns();
2666                    emitter.emit_order_cancel_rejected_event(
2667                        strategy_id,
2668                        instrument_id,
2669                        client_order_id,
2670                        Some(venue_order_id),
2671                        &reason,
2672                        ts_event,
2673                        Some(cmd.command_id),
2674                    );
2675                }
2676            }
2677
2678            Ok(())
2679        });
2680
2681        Ok(())
2682    }
2683
2684    fn modify_order(&self, cmd: ModifyOrder) -> anyhow::Result<()> {
2685        self.process_pending_resync();
2686
2687        let instrument_id = cmd.instrument_id;
2688        let market_id = extract_market_id(&instrument_id)?;
2689
2690        let venue_order_id = cmd
2691            .venue_order_id
2692            .ok_or_else(|| anyhow::anyhow!("Cannot modify order without venue_order_id"))?;
2693        let bet_id: BetId = venue_order_id.to_string();
2694
2695        // Compare against existing order to determine actual changes
2696        let existing_order = self.core.get_order(&cmd.client_order_id);
2697        let has_price_change = match (&cmd.price, &existing_order) {
2698            (Some(new_price), Ok(order)) => order.price() != Some(*new_price),
2699            (Some(_), Err(_)) => true,
2700            (None, _) => false,
2701        };
2702        let has_quantity_change = match (&cmd.quantity, &existing_order) {
2703            (Some(new_qty), Ok(order)) => order.quantity() != *new_qty,
2704            (Some(_), Err(_)) => true,
2705            (None, _) => false,
2706        };
2707
2708        // Betfair does not support atomic price+quantity modification
2709        if has_price_change && has_quantity_change {
2710            let ts_event = self.clock.get_time_ns();
2711            self.emitter.emit_order_modify_denied_event(
2712                cmd.strategy_id,
2713                instrument_id,
2714                cmd.client_order_id,
2715                Some(venue_order_id),
2716                "cannot modify price and quantity simultaneously on Betfair",
2717                ts_event,
2718                Some(cmd.command_id),
2719            );
2720            return Ok(());
2721        }
2722
2723        let client_order_id = cmd.client_order_id;
2724        let strategy_id = cmd.strategy_id;
2725        let http_client = Arc::clone(&self.http_client);
2726        let emitter = self.emitter.clone();
2727        let clock = self.clock;
2728
2729        if has_price_change {
2730            let new_price = cmd.price.unwrap().as_decimal();
2731            let old_bet_id = bet_id.clone();
2732            let update_price = cmd.price;
2733            let update_qty = existing_order.as_ref().ok().map(|order| order.quantity());
2734
2735            // Track pending replace so the OCM handler suppresses the
2736            // cancel event for the old bet that Betfair emits as part
2737            // of the replace operation.
2738            self.ocm_state.lock().register_pending_replace(
2739                client_order_id,
2740                old_bet_id.clone(),
2741                update_qty,
2742            );
2743
2744            let market_version = self.get_market_version(&instrument_id);
2745
2746            let params = ReplaceOrdersParams {
2747                market_id,
2748                instructions: vec![ReplaceInstruction { bet_id, new_price }],
2749                customer_ref: Some(order_customer_ref()),
2750                market_version,
2751            };
2752
2753            let ocm_state = Arc::clone(&self.ocm_state);
2754
2755            self.spawn_task("modify-order-price", async move {
2756                let result: Result<ReplaceExecutionReport, _> = http_client
2757                    .send_betting_order(METHOD_REPLACE_ORDERS, &params)
2758                    .await;
2759
2760                match result {
2761                    Ok(report) => {
2762                        let instruction_report =
2763                            single_instruction_report(report.instruction_reports.as_deref());
2764                        let instruction_result = instruction_report.map(|ir| {
2765                            classify_replace_instruction(
2766                                ir,
2767                                format_replace_instruction_reason(ir, &report),
2768                            )
2769                        });
2770                        let result = classify_execution_report(
2771                            report.status,
2772                            report.error_code,
2773                            instruction_result,
2774                            || {
2775                                format_betfair_reason(report.error_code, None, "unknown error")
2776                            },
2777                        );
2778
2779                        match result {
2780                            Ok(()) => {
2781                                let new_bet_id = instruction_report
2782                                    .and_then(|ir| ir.place_instruction_report.as_ref())
2783                                    .and_then(|ir| ir.bet_id.as_ref());
2784                                let Some(new_bet_id) = new_bet_id else {
2785                                    ocm_state.lock().mark_pending_replace_ambiguous(
2786                                        client_order_id,
2787                                        &old_bet_id,
2788                                    );
2789                                    log::warn!(
2790                                        "Replace succeeded without a new bet ID for {client_order_id}; \
2791                                         awaiting reconciliation",
2792                                    );
2793                                    return Ok(());
2794                                };
2795
2796                                let new_venue_order_id = VenueOrderId::from(new_bet_id.as_str());
2797                                let replace_was_pending = ocm_state
2798                                    .lock()
2799                                    .complete_pending_replace(
2800                                        client_order_id,
2801                                        &old_bet_id,
2802                                        new_venue_order_id,
2803                                    )
2804                                    .is_some();
2805
2806                                if replace_was_pending
2807                                    && let Some(quantity) = update_qty
2808                                {
2809                                    let ts_event = clock.get_time_ns();
2810                                    let updated = OrderUpdated::new(
2811                                        emitter.trader_id(),
2812                                        strategy_id,
2813                                        instrument_id,
2814                                        client_order_id,
2815                                        quantity,
2816                                        UUID4::new(),
2817                                        ts_event,
2818                                        ts_event,
2819                                        false,
2820                                        Some(new_venue_order_id),
2821                                        Some(emitter.account_id()),
2822                                        update_price,
2823                                        None,
2824                                        None,
2825                                        false,
2826                                    );
2827                                    emitter.send_order_event(OrderEventAny::Updated(updated));
2828                                }
2829                            }
2830                            Err(CommandFailure::Ambiguous(_)) => {
2831                                ocm_state.lock().mark_pending_replace_ambiguous(
2832                                    client_order_id,
2833                                    &old_bet_id,
2834                                );
2835                                log::warn!(
2836                                    "Ambiguous replace report for {client_order_id}, awaiting reconciliation",
2837                                );
2838                            }
2839                            Err(CommandFailure::VenueRejected(reason))
2840                                if replace_cancelled_without_replacement(instruction_report) =>
2841                            {
2842                                let replace_was_pending = {
2843                                    let mut state = ocm_state.lock();
2844                                    let replace_was_pending = state
2845                                        .take_pending_replace(client_order_id, &old_bet_id)
2846                                        .is_some();
2847
2848                                    if replace_was_pending {
2849                                        state.mark_canceled_replace(
2850                                            client_order_id,
2851                                            &old_bet_id,
2852                                        );
2853                                    }
2854                                    replace_was_pending
2855                                };
2856
2857                                if !replace_was_pending {
2858                                    return Ok(());
2859                                }
2860                                log::warn!(
2861                                    "Replace canceled {client_order_id} without placing its replacement: {reason}",
2862                                );
2863                                let ts_event = clock.get_time_ns();
2864                                let canceled = OrderCanceled::new(
2865                                    emitter.trader_id(),
2866                                    strategy_id,
2867                                    instrument_id,
2868                                    client_order_id,
2869                                    UUID4::new(),
2870                                    ts_event,
2871                                    ts_event,
2872                                    false,
2873                                    Some(venue_order_id),
2874                                    Some(emitter.account_id()),
2875                                    None,
2876                                );
2877                                emitter.send_order_event(OrderEventAny::Canceled(canceled));
2878                            }
2879                            Err(
2880                                ref failure @ (CommandFailure::NotSent(ref reason)
2881                                | CommandFailure::VenueRejected(ref reason)),
2882                            ) => {
2883                                emit_replace_failure(
2884                                    &ocm_state,
2885                                    &emitter,
2886                                    clock,
2887                                    strategy_id,
2888                                    instrument_id,
2889                                    client_order_id,
2890                                    venue_order_id,
2891                                    &old_bet_id,
2892                                    reason,
2893                                    failure,
2894                                    cmd.command_id,
2895                                );
2896                            }
2897                        }
2898                    }
2899                    Err(e) => {
2900                        match classify_http_error(&e) {
2901                            CommandFailure::Ambiguous(_) => {
2902                                ocm_state.lock().mark_pending_replace_ambiguous(
2903                                    client_order_id,
2904                                    &old_bet_id,
2905                                );
2906                                log::warn!(
2907                                    "Ambiguous replace response for {client_order_id}, awaiting reconciliation: {e}",
2908                                );
2909                            }
2910                            failure @ (CommandFailure::NotSent(_)
2911                            | CommandFailure::VenueRejected(_)) => {
2912                                emit_replace_failure(
2913                                    &ocm_state,
2914                                    &emitter,
2915                                    clock,
2916                                    strategy_id,
2917                                    instrument_id,
2918                                    client_order_id,
2919                                    venue_order_id,
2920                                    &old_bet_id,
2921                                    &format!("modify-order error: {e}"),
2922                                    &failure,
2923                                    cmd.command_id,
2924                                );
2925                            }
2926                        }
2927                    }
2928                }
2929
2930                Ok(())
2931            });
2932        } else if has_quantity_change {
2933            // Quantity reduction via partial cancel
2934            let order = self.core.get_order(&client_order_id)?;
2935            let original_quantity = order.quantity();
2936            let requested_quantity = cmd.quantity.unwrap();
2937            let existing_qty = original_quantity.as_decimal();
2938            let new_qty = requested_quantity.as_decimal();
2939
2940            if new_qty >= existing_qty {
2941                let ts_event = self.clock.get_time_ns();
2942                self.emitter.emit_order_modify_denied_event(
2943                    strategy_id,
2944                    instrument_id,
2945                    client_order_id,
2946                    Some(venue_order_id),
2947                    "can only reduce quantity on Betfair",
2948                    ts_event,
2949                    Some(cmd.command_id),
2950                );
2951                return Ok(());
2952            }
2953
2954            let size_reduction = existing_qty - new_qty;
2955            let reduction_bet_id = bet_id.clone();
2956            let params = CancelOrdersParams {
2957                market_id: Some(market_id),
2958                instructions: Some(vec![CancelInstruction {
2959                    bet_id,
2960                    size_reduction: Some(size_reduction),
2961                }]),
2962                customer_ref: Some(order_customer_ref()),
2963            };
2964
2965            // Register before sending so OCM can resolve before REST
2966            self.ocm_state.lock().register_pending_reduction(
2967                client_order_id,
2968                reduction_bet_id.clone(),
2969                original_quantity,
2970                requested_quantity,
2971            );
2972
2973            let ocm_state = Arc::clone(&self.ocm_state);
2974
2975            self.spawn_task("modify-order-quantity", async move {
2976                let result: Result<CancelExecutionReport, _> = http_client
2977                    .send_betting_order(METHOD_CANCEL_ORDERS, &params)
2978                    .await;
2979
2980                match result {
2981                    Err(e) => {
2982                        match classify_http_error(&e) {
2983                            CommandFailure::Ambiguous(_) => log::warn!(
2984                                "Ambiguous quantity reduction for {client_order_id}, awaiting reconciliation: {e}",
2985                            ),
2986                            CommandFailure::NotSent(_) => {
2987                                ocm_state
2988                                    .lock()
2989                                    .clear_pending_reduction(&client_order_id, &reduction_bet_id);
2990
2991                                let ts_event = clock.get_time_ns();
2992                                emitter.emit_order_modify_denied_event(
2993                                    strategy_id,
2994                                    instrument_id,
2995                                    client_order_id,
2996                                    Some(venue_order_id),
2997                                    &format!("modify-order error: {e}"),
2998                                    ts_event,
2999                                    Some(cmd.command_id),
3000                                );
3001                            }
3002                            CommandFailure::VenueRejected(_) => {
3003                                ocm_state
3004                                    .lock()
3005                                    .clear_pending_reduction(&client_order_id, &reduction_bet_id);
3006
3007                                let ts_event = clock.get_time_ns();
3008                                emitter.emit_order_modify_rejected_event(
3009                                    strategy_id,
3010                                    instrument_id,
3011                                    client_order_id,
3012                                    Some(venue_order_id),
3013                                    &format!("modify-order error: {e}"),
3014                                    ts_event,
3015                                    Some(cmd.command_id),
3016                                );
3017                            }
3018                        }
3019                    }
3020                    Ok(report) => {
3021                        let instruction_report =
3022                            single_instruction_report(report.instruction_reports.as_deref());
3023                        let instruction_result = instruction_report.map(|ir| {
3024                            classify_instruction_report(ir.status, ir.error_code, false, || {
3025                                format_cancel_instruction_reason(ir.error_code, report.error_code)
3026                            })
3027                        });
3028                        let result = classify_execution_report(
3029                            report.status,
3030                            report.error_code,
3031                            instruction_result,
3032                            || {
3033                                format_betfair_reason(report.error_code, None, "unknown error")
3034                            },
3035                        );
3036
3037                        match result {
3038                            Err(CommandFailure::Ambiguous(_)) => log::warn!(
3039                                "Ambiguous quantity reduction report for {client_order_id}, awaiting reconciliation",
3040                            ),
3041                            Err(CommandFailure::NotSent(reason)) => {
3042                                ocm_state
3043                                    .lock()
3044                                    .clear_pending_reduction(&client_order_id, &reduction_bet_id);
3045
3046                                let ts_event = clock.get_time_ns();
3047                                emitter.emit_order_modify_denied_event(
3048                                    strategy_id,
3049                                    instrument_id,
3050                                    client_order_id,
3051                                    Some(venue_order_id),
3052                                    &reason,
3053                                    ts_event,
3054                                    Some(cmd.command_id),
3055                                );
3056                            }
3057                            Err(CommandFailure::VenueRejected(reason)) => {
3058                                ocm_state
3059                                    .lock()
3060                                    .clear_pending_reduction(&client_order_id, &reduction_bet_id);
3061
3062                                let ts_event = clock.get_time_ns();
3063                                emitter.emit_order_modify_rejected_event(
3064                                    strategy_id,
3065                                    instrument_id,
3066                                    client_order_id,
3067                                    Some(venue_order_id),
3068                                    &reason,
3069                                    ts_event,
3070                                    Some(cmd.command_id),
3071                                );
3072                            }
3073                            Ok(()) => {
3074                                let Some(updated_quantity) = instruction_report
3075                                    .and_then(|ir| ir.size_cancelled)
3076                                    .and_then(|cancelled| {
3077                                        parse_betfair_quantity(existing_qty - cancelled).ok()
3078                                    })
3079                                else {
3080                                    log::warn!(
3081                                        "Quantity reduction succeeded without a valid cancelled size for {client_order_id}; \
3082                                         awaiting reconciliation",
3083                                    );
3084                                    return Ok(());
3085                                };
3086
3087                                let newly_resolved = ocm_state
3088                                    .lock()
3089                                    .complete_pending_reduction(
3090                                        &client_order_id,
3091                                        &reduction_bet_id,
3092                                        updated_quantity,
3093                                    );
3094
3095                                if !newly_resolved {
3096                                    log::debug!(
3097                                        "Suppressing late reduction update for {client_order_id}: \
3098                                         already resolved from another channel",
3099                                    );
3100                                    return Ok(());
3101                                }
3102
3103                                let ts_event = clock.get_time_ns();
3104                                let updated = OrderUpdated::new(
3105                                    emitter.trader_id(),
3106                                    strategy_id,
3107                                    instrument_id,
3108                                    client_order_id,
3109                                    updated_quantity,
3110                                    UUID4::new(),
3111                                    ts_event,
3112                                    ts_event,
3113                                    false,
3114                                    Some(venue_order_id),
3115                                    Some(emitter.account_id()),
3116                                    None,
3117                                    None,
3118                                    None,
3119                                    false,
3120                                );
3121                                emitter.send_order_event(OrderEventAny::Updated(updated));
3122                            }
3123                        }
3124                    }
3125                }
3126
3127                Ok(())
3128            });
3129        } else {
3130            let ts_event = self.clock.get_time_ns();
3131            self.emitter.emit_order_modify_denied_event(
3132                strategy_id,
3133                instrument_id,
3134                client_order_id,
3135                Some(venue_order_id),
3136                "no effective change in price or quantity",
3137                ts_event,
3138                Some(cmd.command_id),
3139            );
3140        }
3141
3142        Ok(())
3143    }
3144
3145    fn cancel_all_orders(&self, cmd: CancelAllOrders) -> anyhow::Result<()> {
3146        self.process_pending_resync();
3147
3148        let instrument_id = cmd.instrument_id;
3149        let market_id = match extract_market_id(&instrument_id) {
3150            Ok(market_id) => market_id,
3151            Err(e) => {
3152                log::warn!("Cannot cancel all orders for {instrument_id}: {e}");
3153                return Ok(());
3154            }
3155        };
3156
3157        let Some(order_side) = cmd.order_side else {
3158            let params = CancelOrdersParams {
3159                market_id: Some(market_id),
3160                instructions: None,
3161                customer_ref: Some(order_customer_ref()),
3162            };
3163
3164            let http_client = Arc::clone(&self.http_client);
3165
3166            self.spawn_task("cancel-all-orders", async move {
3167                let result = http_client
3168                    .send_betting_order::<serde_json::Value, _>(METHOD_CANCEL_ORDERS, &params)
3169                    .await;
3170
3171                if let Err(e) = result {
3172                    log::warn!("Failed to cancel all orders: {e}");
3173                }
3174
3175                Ok(())
3176            });
3177
3178            return Ok(());
3179        };
3180
3181        let cache = self.core.cache();
3182        let orders = cache.orders_open_refs(
3183            Some(&self.core.venue),
3184            Some(&instrument_id),
3185            None,
3186            Some(&self.core.account_id),
3187            Some(order_side),
3188        );
3189        let mut cancels = Vec::with_capacity(orders.len());
3190
3191        for order in orders {
3192            let client_order_id = order.client_order_id();
3193            if cache.client_id(&client_order_id) != Some(&self.core.client_id) {
3194                continue;
3195            }
3196
3197            let Some(venue_order_id) = order.venue_order_id() else {
3198                log::warn!(
3199                    "Cannot cancel all {order_side} orders for {instrument_id}: \
3200                     order {client_order_id} has no venue_order_id",
3201                );
3202                return Ok(());
3203            };
3204
3205            cancels.push(CancelOrderData {
3206                command_id: cmd.command_id,
3207                strategy_id: order.strategy_id(),
3208                instrument_id: order.instrument_id(),
3209                client_order_id,
3210                venue_order_id,
3211                sp_bet: is_sp_order(&order),
3212            });
3213        }
3214        drop(cache);
3215
3216        if cancels.is_empty() {
3217            return Ok(());
3218        }
3219
3220        self.spawn_cancel_orders("cancel-all-orders-by-side", market_id, cancels, false);
3221
3222        Ok(())
3223    }
3224
3225    fn batch_cancel_orders(&self, cmd: BatchCancelOrders) -> anyhow::Result<()> {
3226        self.process_pending_resync();
3227
3228        let instrument_id = cmd.instrument_id;
3229        let market_id = match extract_market_id(&instrument_id) {
3230            Ok(market_id) => market_id,
3231            Err(e) => {
3232                log::warn!("Cannot batch cancel orders for {instrument_id}: {e}");
3233                return Ok(());
3234            }
3235        };
3236
3237        let mut cancels = Vec::new();
3238
3239        let cache = self.core.cache();
3240
3241        for cancel in &cmd.cancels {
3242            match cancel.venue_order_id {
3243                Some(venue_order_id) => {
3244                    let sp_bet = cache
3245                        .order(&cancel.client_order_id)
3246                        .is_some_and(|order| is_sp_order(&order));
3247                    cancels.push(CancelOrderData {
3248                        command_id: cancel.command_id,
3249                        strategy_id: cancel.strategy_id,
3250                        instrument_id: cancel.instrument_id,
3251                        client_order_id: cancel.client_order_id,
3252                        venue_order_id,
3253                        sp_bet,
3254                    });
3255                }
3256                None => {
3257                    log::warn!(
3258                        "Cannot batch cancel order {}: no venue_order_id",
3259                        cancel.client_order_id,
3260                    );
3261                }
3262            }
3263        }
3264
3265        if cancels.is_empty() {
3266            return Ok(());
3267        }
3268
3269        self.spawn_cancel_orders("batch-cancel-orders", market_id, cancels, true);
3270
3271        Ok(())
3272    }
3273
3274    fn submit_order_list(&self, cmd: SubmitOrderList) -> anyhow::Result<()> {
3275        self.process_pending_resync();
3276
3277        let orders = self.core.get_orders_for_list(&cmd.order_list)?;
3278
3279        if let Some(reason) = orders.iter().find_map(|order| validate_order(order).err()) {
3280            let reason = reason.to_string();
3281
3282            for order in &orders {
3283                self.emitter.emit_order_denied(order, &reason);
3284            }
3285
3286            return Ok(());
3287        }
3288
3289        if self.submissions_halted() {
3290            log::warn!(
3291                "Halting submit_order_list ({} orders) while the execution stream is \
3292                 unavailable or reconciling",
3293                cmd.order_list.client_order_ids.len(),
3294            );
3295
3296            let denied = OrderDeniedReason::StreamReconciling.to_string();
3297
3298            for client_order_id in &cmd.order_list.client_order_ids {
3299                if let Ok(order) = self.core.get_order(client_order_id) {
3300                    self.emitter.emit_order_denied(&order, &denied);
3301                }
3302            }
3303            return Ok(());
3304        }
3305
3306        let instrument_id = cmd.instrument_id;
3307        let market_id = extract_market_id(&instrument_id)?;
3308        let (selection_id, handicap) = extract_selection_id(&instrument_id)?;
3309
3310        let mut candidates = Vec::new();
3311
3312        for order in orders {
3313            if order.is_closed() {
3314                log::warn!("Skipping closed order {}", order.client_order_id());
3315                continue;
3316            }
3317
3318            let instruction = create_place_instruction(&order, selection_id, handicap)?;
3319            candidates.push((instruction, order));
3320        }
3321
3322        let mut instructions = Vec::new();
3323        let mut order_snapshots = Vec::new();
3324        let mut collisions = Vec::new();
3325        {
3326            let mut state = self.ocm_state.lock();
3327
3328            for (instruction, order) in candidates {
3329                match state.register_submission(order.client_order_id(), order.strategy_id()) {
3330                    Ok(()) => {
3331                        instructions.push(instruction);
3332                        order_snapshots.push((order.client_order_id(), order.strategy_id(), order));
3333                    }
3334                    Err(customer_order_ref) => {
3335                        collisions.push((order, customer_order_ref));
3336                    }
3337                }
3338            }
3339        }
3340
3341        for (order, customer_order_ref) in collisions {
3342            let reason = customer_order_ref_collision_reason(&customer_order_ref);
3343            log::warn!(
3344                "Denying order list leg {}: {reason}",
3345                order.client_order_id(),
3346            );
3347            self.emitter.emit_order_denied(&order, &reason);
3348        }
3349
3350        if instructions.is_empty() {
3351            return Ok(());
3352        }
3353
3354        let market_version = self.get_market_version(&instrument_id);
3355
3356        let params = PlaceOrdersParams {
3357            market_id,
3358            instructions,
3359            customer_ref: Some(order_customer_ref()),
3360            market_version,
3361            customer_strategy_ref: None,
3362        };
3363
3364        for (_, _, order) in &order_snapshots {
3365            log::debug!("OrderSubmitted client_order_id={}", order.client_order_id());
3366            self.emitter.emit_order_submitted(order);
3367        }
3368
3369        let http_client = Arc::clone(&self.http_client);
3370        let emitter = self.emitter.clone();
3371        let clock = self.clock;
3372        let ocm_state = Arc::clone(&self.ocm_state);
3373
3374        self.spawn_task("submit-order-list", async move {
3375            let report: PlaceExecutionReport = match http_client
3376                .send_betting_order(METHOD_PLACE_ORDERS, &params)
3377                .await
3378            {
3379                Ok(r) => r,
3380                Err(e) => {
3381                    match classify_http_error(&e) {
3382                        CommandFailure::Ambiguous(_) => log::warn!(
3383                            "Ambiguous submit response for order list: {e}. \
3384                             Orders may be live, awaiting OCM reconciliation",
3385                        ),
3386                        CommandFailure::NotSent(_) | CommandFailure::VenueRejected(_) => {
3387                            let ts_event = clock.get_time_ns();
3388                            let reason = format!("submit-order-list error: {e}");
3389
3390                            for (client_oid, strategy_id, _) in &order_snapshots {
3391                                emit_http_reject_if_unreported(
3392                                    &ocm_state,
3393                                    client_oid,
3394                                    &reason,
3395                                    || {
3396                                        emitter.emit_order_rejected_event(
3397                                            *strategy_id,
3398                                            instrument_id,
3399                                            *client_oid,
3400                                            &reason,
3401                                            ts_event,
3402                                            false,
3403                                        );
3404                                    },
3405                                );
3406                            }
3407                        }
3408                    }
3409                    return Ok(());
3410                }
3411            };
3412
3413            let instruction_reports = report.instruction_reports.as_deref().unwrap_or_default();
3414            if instruction_reports.len() > order_snapshots.len() {
3415                log::warn!(
3416                    "Order list returned {} reports for {} instructions; ignoring unmatched reports",
3417                    instruction_reports.len(),
3418                    order_snapshots.len(),
3419                );
3420            }
3421
3422            for (index, (client_oid, strategy_id, order)) in
3423                order_snapshots.iter().enumerate()
3424            {
3425                let instruction_report = instruction_reports.get(index);
3426                let instruction_result = instruction_report.map(|ir| {
3427                    classify_instruction_report(ir.status, ir.error_code, false, || {
3428                        format_place_instruction_reason(ir, &report)
3429                    })
3430                });
3431                let result = classify_execution_report(
3432                    report.status,
3433                    report.error_code,
3434                    instruction_result,
3435                    || {
3436                        format_betfair_reason(report.error_code, None, "unknown error")
3437                    },
3438                );
3439
3440                match result {
3441                    Ok(()) => {
3442                        if let Some(bet_id) = instruction_report.and_then(|ir| ir.bet_id.as_ref()) {
3443                            let venue_order_id = VenueOrderId::from(bet_id.as_str());
3444                            let ts_event = clock.get_time_ns();
3445                            emit_http_accept_if_claimed(
3446                                &ocm_state,
3447                                client_oid,
3448                                venue_order_id,
3449                                || emitter.emit_order_accepted(order, venue_order_id, ts_event),
3450                            );
3451                        } else {
3452                            log::warn!(
3453                                "Submit succeeded without a bet ID for {client_oid}; \
3454                                 awaiting OCM reconciliation",
3455                            );
3456                        }
3457                    }
3458                    Err(CommandFailure::Ambiguous(_)) => log::warn!(
3459                        "Ambiguous submit result for {client_oid}, awaiting OCM reconciliation",
3460                    ),
3461                    Err(
3462                        CommandFailure::NotSent(reason)
3463                        | CommandFailure::VenueRejected(reason),
3464                    ) => {
3465                        emit_http_reject_if_unreported(
3466                            &ocm_state,
3467                            client_oid,
3468                            &reason,
3469                            || {
3470                                let ts_event = clock.get_time_ns();
3471                                emitter.emit_order_rejected_event(
3472                                    *strategy_id,
3473                                    instrument_id,
3474                                    *client_oid,
3475                                    &reason,
3476                                    ts_event,
3477                                    false,
3478                                );
3479                            },
3480                        );
3481                    }
3482                }
3483            }
3484
3485            Ok(())
3486        });
3487
3488        Ok(())
3489    }
3490}
3491
3492const MAX_CANCEL_ORDERS_INSTRUCTIONS: usize = 60;
3493
3494#[derive(Clone, Copy, Debug)]
3495struct CancelOrderData {
3496    command_id: UUID4,
3497    strategy_id: StrategyId,
3498    instrument_id: InstrumentId,
3499    client_order_id: ClientOrderId,
3500    venue_order_id: VenueOrderId,
3501    sp_bet: bool,
3502}
3503
3504impl BetfairExecutionClient {
3505    fn spawn_cancel_orders(
3506        &self,
3507        task_name: &'static str,
3508        market_id: String,
3509        cancels: Vec<CancelOrderData>,
3510        emit_rejections: bool,
3511    ) {
3512        let http_client = Arc::clone(&self.http_client);
3513        let emitter = self.emitter.clone();
3514        let clock = self.clock;
3515
3516        self.spawn_task(task_name, async move {
3517            for cancels in cancels.chunks(MAX_CANCEL_ORDERS_INSTRUCTIONS) {
3518                let params = CancelOrdersParams {
3519                    market_id: Some(market_id.clone()),
3520                    instructions: Some(
3521                        cancels
3522                            .iter()
3523                            .map(|cancel| CancelInstruction {
3524                                bet_id: cancel.venue_order_id.to_string(),
3525                                size_reduction: None,
3526                            })
3527                            .collect(),
3528                    ),
3529                    customer_ref: Some(order_customer_ref()),
3530                };
3531                let report: CancelExecutionReport = match http_client
3532                    .send_betting_order(METHOD_CANCEL_ORDERS, &params)
3533                    .await
3534                {
3535                    Ok(report) => report,
3536                    Err(e) => {
3537                        match classify_http_error(&e) {
3538                            CommandFailure::Ambiguous(_) => log::warn!(
3539                                "Ambiguous {task_name} response for {} orders, awaiting OCM reconciliation: {e}",
3540                                cancels.len(),
3541                            ),
3542                            CommandFailure::NotSent(_) => {
3543                                let reason = format!("{task_name} error: {e}");
3544                                emit_cancel_denials(&emitter, clock, cancels, &reason);
3545                            }
3546                            CommandFailure::VenueRejected(_) => {
3547                                let reason = format!("{task_name} error: {e}");
3548
3549                                if emit_rejections {
3550                                    let ts_event = clock.get_time_ns();
3551
3552                                    for cancel in cancels {
3553                                        emitter.emit_order_cancel_rejected_event(
3554                                            cancel.strategy_id,
3555                                            cancel.instrument_id,
3556                                            cancel.client_order_id,
3557                                            Some(cancel.venue_order_id),
3558                                            &reason,
3559                                            ts_event,
3560                                            Some(cancel.command_id),
3561                                        );
3562                                    }
3563                                } else {
3564                                    for cancel in cancels {
3565                                        log::warn!(
3566                                            "Cancel {} was rejected: {reason}",
3567                                            cancel.client_order_id,
3568                                        );
3569                                    }
3570                                }
3571                            }
3572                        }
3573                        continue;
3574                    }
3575                };
3576
3577                let instruction_reports = report.instruction_reports.as_deref().unwrap_or_default();
3578                if instruction_reports.len() > cancels.len() {
3579                    log::warn!(
3580                        "{task_name} returned {} reports for {} instructions; ignoring unmatched reports",
3581                        instruction_reports.len(),
3582                        cancels.len(),
3583                    );
3584                }
3585
3586                for (index, cancel) in cancels.iter().enumerate() {
3587                    let instruction_report = instruction_reports.get(index);
3588                    let instruction_result = instruction_report.map(|ir| {
3589                        classify_instruction_report(ir.status, ir.error_code, !cancel.sp_bet, || {
3590                            format_cancel_instruction_reason(ir.error_code, report.error_code)
3591                        })
3592                    });
3593                    let result = classify_execution_report(
3594                        report.status,
3595                        report.error_code,
3596                        instruction_result,
3597                        || format_betfair_reason(report.error_code, None, "unknown error"),
3598                    );
3599
3600                    match result {
3601                        Ok(()) => {
3602                            if instruction_report.is_some_and(|ir| {
3603                                ir.error_code == Some(InstructionReportErrorCode::BetTakenOrLapsed)
3604                            }) {
3605                                log::debug!(
3606                                    "Cancel {}: BetTakenOrLapsed, treating as success",
3607                                    cancel.client_order_id,
3608                                );
3609                            }
3610                        }
3611                        Err(CommandFailure::Ambiguous(_)) => log::warn!(
3612                            "Ambiguous cancel result for {}, awaiting OCM reconciliation",
3613                            cancel.client_order_id,
3614                        ),
3615                        Err(CommandFailure::NotSent(reason)) => {
3616                            emit_cancel_denials(
3617                                &emitter,
3618                                clock,
3619                                std::slice::from_ref(cancel),
3620                                &reason,
3621                            );
3622                        }
3623                        Err(CommandFailure::VenueRejected(reason)) => {
3624                            if emit_rejections {
3625                                emitter.emit_order_cancel_rejected_event(
3626                                    cancel.strategy_id,
3627                                    cancel.instrument_id,
3628                                    cancel.client_order_id,
3629                                    Some(cancel.venue_order_id),
3630                                    &reason,
3631                                    clock.get_time_ns(),
3632                                    Some(cancel.command_id),
3633                                );
3634                            } else {
3635                                log::warn!(
3636                                    "Cancel {} was rejected: {reason}",
3637                                    cancel.client_order_id,
3638                                );
3639                            }
3640                        }
3641                    }
3642                }
3643            }
3644
3645            Ok(())
3646        });
3647    }
3648}
3649
3650fn emit_cancel_denials(
3651    emitter: &ExecutionEventEmitter,
3652    clock: &AtomicTime,
3653    cancels: &[CancelOrderData],
3654    reason: &str,
3655) {
3656    let ts_event = clock.get_time_ns();
3657
3658    for cancel in cancels {
3659        emitter.emit_order_cancel_denied_event(
3660            cancel.strategy_id,
3661            cancel.instrument_id,
3662            cancel.client_order_id,
3663            Some(cancel.venue_order_id),
3664            reason,
3665            ts_event,
3666            Some(cancel.command_id),
3667        );
3668    }
3669}
3670
3671fn validate_order(order: &impl Order) -> Result<(), OrderDeniedReason> {
3672    if order.is_reduce_only() {
3673        return Err(OrderDeniedReason::UnsupportedReduceOnly);
3674    }
3675
3676    match order.order_type() {
3677        OrderType::Limit => Ok(()),
3678        OrderType::Market if order.time_in_force() != TimeInForce::AtTheClose => Err(
3679            OrderDeniedReason::UnsupportedTimeInForce(order.time_in_force()),
3680        ),
3681        OrderType::Market => Ok(()),
3682        order_type => Err(OrderDeniedReason::UnsupportedOrderType { order_type }),
3683    }
3684}
3685
3686// SP bets cannot be cancelled once placed.
3687fn is_sp_order(order: &OrderAny) -> bool {
3688    matches!(
3689        order.time_in_force(),
3690        TimeInForce::AtTheClose | TimeInForce::AtTheOpen
3691    )
3692}
3693
3694fn create_place_instruction(
3695    order: &impl Order,
3696    selection_id: SelectionId,
3697    handicap: Decimal,
3698) -> anyhow::Result<PlaceInstruction> {
3699    let side = BetfairSide::from(order.order_side());
3700    let size = order.quantity().as_decimal();
3701    let handicap = (handicap != Decimal::ZERO).then_some(handicap);
3702    let customer_order_ref = Some(make_customer_order_ref(order.client_order_id().as_str()));
3703
3704    match order.order_type() {
3705        OrderType::Limit => {
3706            let price = order
3707                .price()
3708                .ok_or_else(|| anyhow::anyhow!("Limit order missing price"))?
3709                .as_decimal();
3710
3711            if matches!(
3712                order.time_in_force(),
3713                TimeInForce::AtTheClose | TimeInForce::AtTheOpen
3714            ) {
3715                return Ok(PlaceInstruction {
3716                    order_type: BetfairOrderType::LimitOnClose,
3717                    selection_id,
3718                    handicap,
3719                    side,
3720                    limit_order: None,
3721                    limit_on_close_order: Some(LimitOnCloseOrder {
3722                        liability: size,
3723                        price,
3724                    }),
3725                    market_on_close_order: None,
3726                    customer_order_ref,
3727                });
3728            }
3729
3730            let (persistence_type, time_in_force, min_fill_size) = match order.time_in_force() {
3731                TimeInForce::Ioc => (
3732                    None,
3733                    Some(BetfairTimeInForce::FillOrKill),
3734                    Some(Decimal::ZERO),
3735                ),
3736                TimeInForce::Fok => (None, Some(BetfairTimeInForce::FillOrKill), None),
3737                TimeInForce::Gtc => (Some(PersistenceType::Persist), None, None),
3738                _ => (Some(PersistenceType::Lapse), None, None),
3739            };
3740
3741            Ok(PlaceInstruction {
3742                order_type: BetfairOrderType::Limit,
3743                selection_id,
3744                handicap,
3745                side,
3746                limit_order: Some(LimitOrder {
3747                    size,
3748                    price,
3749                    persistence_type,
3750                    time_in_force,
3751                    min_fill_size,
3752                    bet_target_type: None,
3753                    bet_target_size: None,
3754                }),
3755                limit_on_close_order: None,
3756                market_on_close_order: None,
3757                customer_order_ref,
3758            })
3759        }
3760        OrderType::Market => {
3761            if order.time_in_force() != TimeInForce::AtTheClose {
3762                anyhow::bail!(
3763                    "Market orders on Betfair are only supported with AtTheClose \
3764                     time in force (BSP MarketOnClose)"
3765                );
3766            }
3767
3768            Ok(PlaceInstruction {
3769                order_type: BetfairOrderType::MarketOnClose,
3770                selection_id,
3771                handicap,
3772                side,
3773                limit_order: None,
3774                limit_on_close_order: None,
3775                market_on_close_order: Some(MarketOnCloseOrder { liability: size }),
3776                customer_order_ref,
3777            })
3778        }
3779        other => anyhow::bail!("Unsupported order type for Betfair: {other:?}"),
3780    }
3781}
3782
3783fn customer_order_ref_collision_reason(customer_order_ref: &str) -> String {
3784    OrderDeniedReason::ValidationFailed {
3785        detail: format!(
3786            "customerOrderRef {customer_order_ref} collides with another tracked order"
3787        ),
3788    }
3789    .to_string()
3790}
3791
3792// Even states admit submissions; each halt advances to a distinct odd generation.
3793// The commit lock makes generation validation, publication, and reopening one boundary.
3794#[derive(Debug)]
3795struct ReconciliationGate {
3796    state: AtomicU64,
3797    commit_lock: Mutex<()>,
3798    state_tx: tokio::sync::watch::Sender<u64>,
3799}
3800
3801impl Default for ReconciliationGate {
3802    fn default() -> Self {
3803        let (state_tx, _) = tokio::sync::watch::channel(0);
3804        Self {
3805            state: AtomicU64::new(0),
3806            commit_lock: Mutex::new(()),
3807            state_tx,
3808        }
3809    }
3810}
3811
3812impl ReconciliationGate {
3813    fn is_halted(&self) -> bool {
3814        self.state.load(Ordering::Acquire) & 1 == 1
3815    }
3816
3817    fn halt(&self) -> u64 {
3818        let _commit = self.commit_lock.lock();
3819        let mut current = self.state.load(Ordering::Acquire);
3820
3821        loop {
3822            let next = if current == u64::MAX {
3823                current
3824            } else if current & 1 == 0 {
3825                current + 1
3826            } else {
3827                current.saturating_add(2)
3828            };
3829
3830            if next == current {
3831                return current;
3832            }
3833
3834            match self.state.compare_exchange_weak(
3835                current,
3836                next,
3837                Ordering::AcqRel,
3838                Ordering::Acquire,
3839            ) {
3840                Ok(_) => {
3841                    self.state_tx.send_replace(next);
3842                    return next;
3843                }
3844                Err(actual) => current = actual,
3845            }
3846        }
3847    }
3848
3849    #[cfg(test)]
3850    fn try_resume(&self, generation: u64) -> bool {
3851        let _commit = self.commit_lock.lock();
3852        self.try_resume_locked(generation)
3853    }
3854
3855    fn try_resume_locked(&self, generation: u64) -> bool {
3856        generation != u64::MAX
3857            && generation & 1 == 1
3858            && self
3859                .state
3860                .compare_exchange(
3861                    generation,
3862                    generation + 1,
3863                    Ordering::AcqRel,
3864                    Ordering::Acquire,
3865                )
3866                .is_ok_and(|_| {
3867                    self.state_tx.send_replace(generation + 1);
3868                    true
3869                })
3870    }
3871
3872    fn is_current(&self, generation: u64) -> bool {
3873        self.state.load(Ordering::Acquire) == generation
3874    }
3875
3876    fn current_generation(&self) -> u64 {
3877        self.state.load(Ordering::Acquire)
3878    }
3879
3880    fn subscribe(&self) -> tokio::sync::watch::Receiver<u64> {
3881        self.state_tx.subscribe()
3882    }
3883
3884    fn commit<F>(&self, generation: u64, publish: F) -> anyhow::Result<bool>
3885    where
3886        F: FnOnce() -> anyhow::Result<()>,
3887    {
3888        let _commit = self.commit_lock.lock();
3889
3890        if !self.is_current(generation) {
3891            return Ok(false);
3892        }
3893
3894        publish()?;
3895        Ok(self.try_resume_locked(generation))
3896    }
3897
3898    fn clear(&self) {
3899        let _commit = self.commit_lock.lock();
3900        let mut current = self.state.load(Ordering::Acquire);
3901
3902        while current & 1 == 1 {
3903            match self.state.compare_exchange_weak(
3904                current,
3905                current.wrapping_add(1),
3906                Ordering::AcqRel,
3907                Ordering::Acquire,
3908            ) {
3909                Ok(_) => {
3910                    self.state_tx.send_replace(current.wrapping_add(1));
3911                    return;
3912                }
3913                Err(actual) => current = actual,
3914            }
3915        }
3916    }
3917}
3918
3919fn commit_post_reconnect_mass_status(
3920    gate: &ReconciliationGate,
3921    generation: u64,
3922    ocm_state: &Arc<Mutex<OcmState>>,
3923    emitter: &ExecutionEventEmitter,
3924    mut recovery: MassStatusSnapshot,
3925) -> anyhow::Result<Option<(usize, usize, Option<AccountState>)>> {
3926    let account_state = recovery.account_state.take();
3927    let mut committed = None;
3928    let published = gate.commit(generation, || {
3929        let mut state = ocm_state.lock();
3930        let mut staged_state = state.clone();
3931        let (mass_status, updates) = recovery.build(&mut staged_state, emitter)?;
3932        let order_count = mass_status.order_reports().len();
3933        let fill_count = mass_status
3934            .fill_reports()
3935            .values()
3936            .map(Vec::len)
3937            .sum::<usize>();
3938
3939        for update in updates {
3940            emitter.try_send_order_event(update)?;
3941        }
3942        emitter.try_send_execution_report(ExecutionReport::MassStatus(Box::new(mass_status)))?;
3943        *state = staged_state;
3944        committed = Some((order_count, fill_count, account_state));
3945        Ok(())
3946    })?;
3947    Ok(published.then(|| committed.expect("published recovery result must be present")))
3948}
3949
3950#[derive(Debug)]
3951struct ReceivedOcm {
3952    message: OCM,
3953    ts_init: UnixNanos,
3954}
3955
3956struct OcmProcessingContext<'a> {
3957    account_id: AccountId,
3958    currency: Currency,
3959    emitter: &'a ExecutionEventEmitter,
3960    ocm_state: &'a Arc<Mutex<OcmState>>,
3961    data_sender: &'a EventSender<DataEvent>,
3962    ignore_external_orders: bool,
3963    account_refresh_tx: Option<&'a tokio::sync::mpsc::UnboundedSender<()>>,
3964    ts_event: UnixNanos,
3965    ts_init: UnixNanos,
3966}
3967
3968#[derive(Clone, Copy, PartialEq, Eq)]
3969enum CancelAction {
3970    Emit,
3971    Suppress,
3972    RecloseAfterFill,
3973}
3974
3975impl CancelAction {
3976    fn should_reclose_after_fill(
3977        self,
3978        order_status: OrderStatus,
3979        has_fill: bool,
3980        is_canceled_replace: bool,
3981    ) -> bool {
3982        if self != Self::RecloseAfterFill || !has_fill {
3983            return false;
3984        }
3985
3986        match order_status {
3987            OrderStatus::Canceled => true,
3988            OrderStatus::PartiallyFilled => is_canceled_replace,
3989            _ => false,
3990        }
3991    }
3992}
3993
3994fn resolve_cancel_action(
3995    state: &OcmState,
3996    order: &UnmatchedOrder,
3997    client_order_id: Option<&ClientOrderId>,
3998) -> CancelAction {
3999    let Some(client_order_id) = client_order_id else {
4000        return CancelAction::Emit;
4001    };
4002
4003    if state.is_canceled_replace(&order.id) {
4004        return CancelAction::RecloseAfterFill;
4005    }
4006
4007    if !is_terminal_cancel(order) {
4008        return CancelAction::Emit;
4009    }
4010
4011    if state.is_retained_terminal_order(client_order_id) {
4012        CancelAction::RecloseAfterFill
4013    } else if state.should_suppress_cancel(client_order_id, &order.id) {
4014        CancelAction::Suppress
4015    } else {
4016        CancelAction::Emit
4017    }
4018}
4019
4020fn is_terminal_cancel(order: &UnmatchedOrder) -> bool {
4021    order.status == StreamingOrderStatus::ExecutionComplete && has_cancel_quantity(order)
4022}
4023
4024struct UnmatchedOrderContext<'a> {
4025    order: &'a UnmatchedOrder,
4026    instrument_id: InstrumentId,
4027    account_id: AccountId,
4028    currency: Currency,
4029    emitter: &'a ExecutionEventEmitter,
4030    ts_event: UnixNanos,
4031    ts_init: UnixNanos,
4032}
4033
4034#[derive(Default)]
4035struct FetchedOrderStatusReports {
4036    orders: Vec<CurrentOrderSummary>,
4037    reports: Vec<OrderStatusReport>,
4038    active_quantities: AHashMap<String, Quantity>,
4039    voided_quantities: AHashMap<String, Quantity>,
4040    ambiguous_replaces: AHashMap<(ClientOrderId, String), UUID4>,
4041}
4042
4043/// Paginates `list_current_orders` into `OrderStatusReport`s without touching
4044/// the engine cache, so it is callable from any tokio task.
4045#[expect(
4046    clippy::too_many_arguments,
4047    reason = "report context and stream session state remain explicit at the HTTP boundary"
4048)]
4049async fn fetch_order_status_reports_http(
4050    http_client: &Arc<BetfairHttpClient>,
4051    account_id: AccountId,
4052    ts_init: UnixNanos,
4053    market_ids: Option<Vec<String>>,
4054    filter: Option<&GenerateOrderStatusReports>,
4055    ocm_state: &Arc<Mutex<OcmState>>,
4056    emitter: Option<&ExecutionEventEmitter>,
4057    stream_session: StreamSession<'_>,
4058    session_refresh: &mut SessionRefresh,
4059) -> anyhow::Result<Vec<OrderStatusReport>> {
4060    let fetched = collect_order_status_reports_http(
4061        http_client,
4062        account_id,
4063        ts_init,
4064        market_ids,
4065        filter,
4066        ocm_state,
4067        stream_session,
4068        session_refresh,
4069    )
4070    .await?;
4071    Ok(finish_order_status_reports(
4072        fetched, filter, ocm_state, emitter, false,
4073    ))
4074}
4075
4076#[expect(
4077    clippy::too_many_arguments,
4078    reason = "report context and stream session state remain explicit at the HTTP boundary"
4079)]
4080async fn collect_order_status_reports_http(
4081    http_client: &Arc<BetfairHttpClient>,
4082    account_id: AccountId,
4083    ts_init: UnixNanos,
4084    market_ids: Option<Vec<String>>,
4085    filter: Option<&GenerateOrderStatusReports>,
4086    ocm_state: &Arc<Mutex<OcmState>>,
4087    stream_session: StreamSession<'_>,
4088    session_refresh: &mut SessionRefresh,
4089) -> anyhow::Result<FetchedOrderStatusReports> {
4090    let market_ids = if let Some(instrument_id) = filter
4091        .filter(|filter| filter.open_only)
4092        .and_then(|filter| filter.instrument_id)
4093    {
4094        let market_id = extract_market_id(&instrument_id)?;
4095
4096        if market_ids
4097            .as_ref()
4098            .is_some_and(|market_ids| !market_ids.contains(&market_id))
4099        {
4100            return Ok(FetchedOrderStatusReports::default());
4101        }
4102
4103        Some(vec![market_id])
4104    } else {
4105        market_ids
4106    };
4107
4108    let mut fetched = fetch_order_status_reports_snapshot_http(
4109        http_client,
4110        account_id,
4111        ts_init,
4112        market_ids,
4113        filter.is_some_and(|filter| filter.open_only),
4114        ocm_state,
4115        stream_session,
4116        session_refresh,
4117    )
4118    .await?;
4119
4120    if let Some(filter) = filter {
4121        fetched.reports.retain(|report| {
4122            filter
4123                .instrument_id
4124                .is_none_or(|instrument_id| report.instrument_id == instrument_id)
4125        });
4126    }
4127
4128    Ok(fetched)
4129}
4130
4131fn finish_order_status_reports(
4132    mut fetched: FetchedOrderStatusReports,
4133    filter: Option<&GenerateOrderStatusReports>,
4134    ocm_state: &Arc<Mutex<OcmState>>,
4135    emitter: Option<&ExecutionEventEmitter>,
4136    guard_pending_replaces: bool,
4137) -> Vec<OrderStatusReport> {
4138    let mut state = ocm_state.lock();
4139    assign_report_owners(&mut fetched.reports, &state);
4140
4141    if let Some(emitter) = emitter {
4142        let updates = resolve_pending_modifies_in_state(
4143            &mut fetched.reports,
4144            &fetched.active_quantities,
4145            &fetched.voided_quantities,
4146            &mut state,
4147            emitter,
4148            guard_pending_replaces.then_some(&fetched.ambiguous_replaces),
4149        );
4150
4151        for update in updates {
4152            emitter.send_order_event(update);
4153        }
4154    }
4155
4156    drop(state);
4157
4158    if let Some(filter) = filter {
4159        retain_order_status_reports(&mut fetched.reports, filter);
4160    }
4161
4162    fetched.reports
4163}
4164
4165fn assign_report_owners(reports: &mut [OrderStatusReport], state: &OcmState) {
4166    for report in reports {
4167        if let Some(resolution) = state.resolve_order_owner(
4168            report.client_order_id.as_ref().map(ClientOrderId::as_str),
4169            report.venue_order_id.as_str(),
4170        ) {
4171            report.client_order_id = resolution.client_order_id();
4172        }
4173    }
4174}
4175
4176#[expect(
4177    clippy::too_many_arguments,
4178    reason = "report context and stream session state remain explicit at the HTTP boundary"
4179)]
4180async fn fetch_order_status_reports_snapshot_http(
4181    http_client: &Arc<BetfairHttpClient>,
4182    account_id: AccountId,
4183    ts_init: UnixNanos,
4184    market_ids: Option<Vec<String>>,
4185    open_only: bool,
4186    ocm_state: &Arc<Mutex<OcmState>>,
4187    stream_session: StreamSession<'_>,
4188    session_refresh: &mut SessionRefresh,
4189) -> anyhow::Result<FetchedOrderStatusReports> {
4190    let order_projection = if open_only {
4191        Some(OrderProjection::Executable)
4192    } else {
4193        Some(OrderProjection::All)
4194    };
4195
4196    let market_id_batches = list_current_orders_market_id_batches(market_ids.clone());
4197    let merge_batches = market_id_batches.len() > 1;
4198
4199    let queries = market_id_batches
4200        .into_iter()
4201        .map(|market_ids| list_current_orders_filter_markets(market_ids, order_projection))
4202        .collect();
4203
4204    let mut orders = Vec::new();
4205    let mut indexes = AHashMap::new();
4206    fetch_order_status_pages_http(
4207        http_client,
4208        queries,
4209        &mut orders,
4210        &mut indexes,
4211        stream_session,
4212        session_refresh,
4213    )
4214    .await?;
4215
4216    let mut ambiguous_replaces = ocm_state.lock().pending_replace_reconciliation_ids();
4217
4218    if open_only {
4219        let bsp_market_ids = fetch_bsp_market_ids_http(
4220            http_client,
4221            market_ids.clone(),
4222            stream_session,
4223            session_refresh,
4224        )
4225        .await?;
4226
4227        let queries = bsp_market_ids
4228            .chunks(MAX_LIST_CURRENT_ORDERS_MARKET_IDS)
4229            .map(|market_ids| {
4230                list_current_orders_filter_markets(
4231                    Some(market_ids.to_vec()),
4232                    Some(OrderProjection::All),
4233                )
4234            })
4235            .collect();
4236
4237        fetch_order_status_pages_http(
4238            http_client,
4239            queries,
4240            &mut orders,
4241            &mut indexes,
4242            stream_session,
4243            session_refresh,
4244        )
4245        .await?;
4246
4247        let discovered_bet_ids: AHashSet<_> = indexes.keys().cloned().collect();
4248        let (bet_ids, customer_order_refs) =
4249            order_status_supplemental_ids(&orders, &ocm_state.lock());
4250        let mut queried_customer_order_refs = customer_order_refs.clone();
4251        let queries = list_current_orders_supplemental_queries(
4252            bet_ids.difference(&discovered_bet_ids).cloned().collect(),
4253            customer_order_refs.into_keys().collect(),
4254        );
4255        fetch_order_status_pages_http(
4256            http_client,
4257            queries,
4258            &mut orders,
4259            &mut indexes,
4260            stream_session,
4261            session_refresh,
4262        )
4263        .await?;
4264
4265        loop {
4266            let (required_bet_ids, pending_customer_order_refs) = {
4267                let state = ocm_state.lock();
4268                ambiguous_replaces = state.pending_replace_reconciliation_ids();
4269                order_status_supplemental_ids(&orders, &state)
4270            };
4271
4272            let missing: AHashSet<String> = required_bet_ids
4273                .into_iter()
4274                .filter(|bet_id| !indexes.contains_key(bet_id))
4275                .collect();
4276
4277            let customer_order_refs: AHashSet<_> = pending_customer_order_refs
4278                .iter()
4279                .filter(|&(customer_order_ref, bet_ids)| {
4280                    queried_customer_order_refs.get(customer_order_ref) != Some(bet_ids)
4281                })
4282                .map(|(customer_order_ref, _)| customer_order_ref.clone())
4283                .collect();
4284
4285            if missing.is_empty() && customer_order_refs.is_empty() {
4286                break;
4287            }
4288
4289            let before = indexes.len();
4290            queried_customer_order_refs.extend(pending_customer_order_refs);
4291            let queries = list_current_orders_supplemental_queries(missing, customer_order_refs);
4292            fetch_order_status_pages_http(
4293                http_client,
4294                queries,
4295                &mut orders,
4296                &mut indexes,
4297                stream_session,
4298                session_refresh,
4299            )
4300            .await?;
4301
4302            if indexes.len() == before {
4303                let (required_bet_ids, _) =
4304                    order_status_supplemental_ids(&orders, &ocm_state.lock());
4305
4306                if let Some(bet_id) = required_bet_ids
4307                    .iter()
4308                    .find(|bet_id| !indexes.contains_key(*bet_id))
4309                {
4310                    anyhow::bail!("Missing Betfair order history for tracked Bet ID {bet_id}");
4311                }
4312            }
4313        }
4314
4315        if let Some(market_ids) = market_ids {
4316            orders.retain(|order| {
4317                discovered_bet_ids.contains(&order.bet_id) || market_ids.contains(&order.market_id)
4318            });
4319        }
4320    }
4321
4322    let mut reports = Vec::with_capacity(orders.len());
4323    let mut active_quantities = AHashMap::new();
4324    let mut voided_quantities = AHashMap::new();
4325
4326    for order in &orders {
4327        let report = parse_current_order_report(order, account_id, ts_init).map_err(|e| {
4328            anyhow::anyhow!("Failed to parse order report for {}: {e}", order.bet_id)
4329        })?;
4330
4331        let active_quantity = current_order_active_quantity(order).map_err(|e| {
4332            anyhow::anyhow!("Failed to parse active quantity for {}: {e}", order.bet_id)
4333        })?;
4334        let voided_quantity = parse_betfair_quantity(order.size_voided.unwrap_or(Decimal::ZERO))
4335            .map_err(|e| {
4336                anyhow::anyhow!("Failed to parse voided quantity for {}: {e}", order.bet_id)
4337            })?;
4338
4339        active_quantities.insert(order.bet_id.clone(), active_quantity);
4340        voided_quantities.insert(order.bet_id.clone(), voided_quantity);
4341        reports.push(report);
4342    }
4343
4344    if merge_batches {
4345        reports.sort_by_key(|report| (report.ts_accepted, report.venue_order_id));
4346    }
4347
4348    Ok(FetchedOrderStatusReports {
4349        orders,
4350        reports,
4351        active_quantities,
4352        voided_quantities,
4353        ambiguous_replaces,
4354    })
4355}
4356
4357fn order_status_supplemental_ids(
4358    orders: &[CurrentOrderSummary],
4359    state: &OcmState,
4360) -> (AHashSet<String>, AHashMap<String, AHashSet<String>>) {
4361    let client_order_ids = orders
4362        .iter()
4363        .filter_map(|order| {
4364            state
4365                .resolve_order_owner(order.customer_order_ref.as_deref(), &order.bet_id)
4366                .and_then(CustomerOrderRefResolution::client_order_id)
4367                .or_else(|| state.client_order_id_by_venue_order_id(&order.bet_id))
4368        })
4369        .collect();
4370
4371    state.order_status_supplemental_ids(client_order_ids)
4372}
4373
4374fn list_current_orders_supplemental_queries(
4375    bet_ids: AHashSet<String>,
4376    customer_order_refs: AHashSet<String>,
4377) -> Vec<ListCurrentOrdersParams> {
4378    let mut bet_ids: Vec<_> = bet_ids.into_iter().collect();
4379    bet_ids.sort();
4380    let mut customer_order_refs: Vec<_> = customer_order_refs.into_iter().collect();
4381    customer_order_refs.sort();
4382    let mut queries = Vec::new();
4383
4384    for batch in bet_ids.chunks(MAX_LIST_CURRENT_ORDERS_MARKET_IDS) {
4385        let mut params = list_current_orders_filter_bet_id(batch[0].clone());
4386        params.bet_ids = Some(batch.to_vec());
4387        params.order_projection = Some(OrderProjection::All);
4388        queries.push(params);
4389    }
4390
4391    for customer_order_ref in customer_order_refs {
4392        let mut params = list_current_orders_filter_ref(customer_order_ref);
4393        params.order_projection = Some(OrderProjection::All);
4394        queries.push(params);
4395    }
4396
4397    queries
4398}
4399
4400#[derive(serde::Deserialize)]
4401struct BspEvent {
4402    event: Event,
4403}
4404
4405async fn fetch_bsp_market_ids_http(
4406    http_client: &Arc<BetfairHttpClient>,
4407    market_ids: Option<Vec<String>>,
4408    stream_session: StreamSession<'_>,
4409    session_refresh: &mut SessionRefresh,
4410) -> anyhow::Result<Vec<String>> {
4411    const CATALOGUE_LIMIT: u32 = 1000;
4412
4413    let filter = MarketFilter {
4414        bsp_only: Some(true),
4415        with_orders: Some(vec![BetfairOrderStatus::ExecutionComplete.to_string()]),
4416        ..Default::default()
4417    };
4418
4419    let filters = if let Some(market_ids) = market_ids {
4420        market_ids
4421            .chunks(MAX_LIST_CURRENT_ORDERS_MARKET_IDS)
4422            .map(|market_ids| MarketFilter {
4423                market_ids: Some(market_ids.to_vec()),
4424                ..filter.clone()
4425            })
4426            .collect::<Vec<_>>()
4427    } else {
4428        let events: Vec<BspEvent> = send_betting_with_retry(
4429            http_client,
4430            METHOD_LIST_EVENTS,
4431            &serde_json::json!({"filter": filter}),
4432            stream_session,
4433            session_refresh,
4434        )
4435        .await?;
4436        events
4437            .into_iter()
4438            .map(|event| {
4439                let event_id = event.event.id.ok_or_else(|| {
4440                    anyhow::anyhow!("Betfair BSP event discovery returned an event without an ID")
4441                })?;
4442
4443                Ok(MarketFilter {
4444                    event_ids: Some(vec![event_id]),
4445                    ..filter.clone()
4446                })
4447            })
4448            .collect::<anyhow::Result<Vec<_>>>()?
4449    };
4450
4451    let mut bsp_market_ids = AHashSet::new();
4452
4453    for filter in filters {
4454        let market_scoped = filter.market_ids.is_some();
4455
4456        let params = ListMarketCatalogueParams {
4457            filter,
4458            market_projection: None,
4459            sort: None,
4460            max_results: Some(CATALOGUE_LIMIT),
4461            locale: None,
4462        };
4463
4464        let catalogues: Vec<MarketCatalogue> = send_betting_with_retry(
4465            http_client,
4466            METHOD_LIST_MARKET_CATALOGUE,
4467            &params,
4468            stream_session,
4469            session_refresh,
4470        )
4471        .await?;
4472        anyhow::ensure!(
4473            market_scoped || catalogues.len() < CATALOGUE_LIMIT as usize,
4474            "Betfair BSP market discovery reached the catalogue limit for event {:?}",
4475            params.filter.event_ids,
4476        );
4477        bsp_market_ids.extend(catalogues.into_iter().map(|market| market.market_id));
4478    }
4479
4480    let mut bsp_market_ids: Vec<_> = bsp_market_ids.into_iter().collect();
4481    bsp_market_ids.sort_unstable();
4482    Ok(bsp_market_ids)
4483}
4484
4485async fn fetch_order_status_pages_http(
4486    http_client: &Arc<BetfairHttpClient>,
4487    queries: Vec<ListCurrentOrdersParams>,
4488    orders: &mut Vec<CurrentOrderSummary>,
4489    indexes: &mut AHashMap<String, usize>,
4490    stream_session: StreamSession<'_>,
4491    session_refresh: &mut SessionRefresh,
4492) -> anyhow::Result<()> {
4493    for mut params in queries {
4494        let mut from_record = 0;
4495
4496        loop {
4497            params.from_record = (from_record > 0).then_some(from_record);
4498            let response = list_current_orders_with_retry(
4499                http_client,
4500                &params,
4501                stream_session,
4502                session_refresh,
4503            )
4504            .await?;
4505            let page_size = response.current_orders.len() as u32;
4506            if response.more_available && page_size == 0 {
4507                anyhow::bail!("listCurrentOrders returned an empty page with moreAvailable=true");
4508            }
4509
4510            for order in response.current_orders {
4511                if let Some(&index) = indexes.get(&order.bet_id) {
4512                    orders[index] = order;
4513                } else {
4514                    indexes.insert(order.bet_id.clone(), orders.len());
4515                    orders.push(order);
4516                }
4517            }
4518
4519            if !response.more_available {
4520                break;
4521            }
4522
4523            from_record += page_size;
4524        }
4525    }
4526
4527    Ok(())
4528}
4529
4530fn resolve_pending_modifies_in_state(
4531    reports: &mut Vec<OrderStatusReport>,
4532    active_quantities: &AHashMap<String, Quantity>,
4533    voided_quantities: &AHashMap<String, Quantity>,
4534    state: &mut OcmState,
4535    emitter: &ExecutionEventEmitter,
4536    eligible_replaces: Option<&AHashMap<(ClientOrderId, String), UUID4>>,
4537) -> Vec<OrderEventAny> {
4538    let mut updates = Vec::new();
4539    let replaced_fills = replaced_leg_fills_from_reports(reports, voided_quantities, state);
4540
4541    let mut resolved_bet_ids = AHashSet::new();
4542
4543    for report in reports.iter_mut() {
4544        let bet_id = report.venue_order_id.to_string();
4545
4546        if let Some(quantity) = state.reduced_quantity(&bet_id) {
4547            report.quantity = quantity;
4548        }
4549
4550        let Some((client_order_id, strategy_id)) = report_correlation(state, report) else {
4551            continue;
4552        };
4553
4554        if let Some((update, old_bet_id)) =
4555            resolve_pending_replace_report(report, state, emitter, client_order_id, strategy_id)
4556        {
4557            updates.push(update);
4558
4559            if report.order_status.is_closed() {
4560                resolved_bet_ids.insert(old_bet_id);
4561            } else {
4562                resolved_bet_ids.insert(bet_id);
4563            }
4564            continue;
4565        }
4566
4567        if let Some(quantity) = resolve_pending_reduction_from_reconciliation(
4568            state,
4569            active_quantities,
4570            &client_order_id,
4571            &bet_id,
4572            replaced_fills
4573                .get(&client_order_id)
4574                .map_or(Quantity::default(), |fills| fills.matched),
4575            replaced_fills
4576                .get(&client_order_id)
4577                .map_or(Quantity::default(), |fills| fills.voided),
4578        ) {
4579            report.quantity = quantity;
4580            if report.order_status.is_closed() {
4581                state.retain_terminal_order(client_order_id, &bet_id);
4582            } else {
4583                updates.push(make_reconciled_update(
4584                    emitter,
4585                    report,
4586                    client_order_id,
4587                    strategy_id,
4588                    quantity,
4589                    None,
4590                ));
4591                resolved_bet_ids.insert(bet_id);
4592            }
4593            continue;
4594        }
4595
4596        if report.order_status.is_closed() {
4597            state.retain_terminal_order(client_order_id, &bet_id);
4598        }
4599    }
4600
4601    updates.extend(resolve_ambiguous_replaces(
4602        reports,
4603        state,
4604        emitter,
4605        eligible_replaces,
4606    ));
4607
4608    accumulate_replaced_leg_fills(reports, voided_quantities, state);
4609
4610    reports.retain(|report| {
4611        let bet_id = report.venue_order_id.as_str();
4612        !state.should_suppress_replaced_report(bet_id) && !resolved_bet_ids.contains(bet_id)
4613    });
4614
4615    updates
4616}
4617
4618fn resolve_ambiguous_replaces(
4619    reports: &[OrderStatusReport],
4620    state: &mut OcmState,
4621    emitter: &ExecutionEventEmitter,
4622    eligible_replaces: Option<&AHashMap<(ClientOrderId, String), UUID4>>,
4623) -> Vec<OrderEventAny> {
4624    let mut updates = Vec::new();
4625    let current_replace_ids = eligible_replaces.map(|_| state.pending_replace_reconciliation_ids());
4626
4627    let non_actionable_replaces = reports
4628        .iter()
4629        .filter_map(|report| {
4630            let bet_id = report.venue_order_id.to_string();
4631            let (client_order_id, strategy_id) = report_correlation(state, report)?;
4632
4633            if let Some(eligible_replaces) = eligible_replaces {
4634                let key = (client_order_id, bet_id.clone());
4635                let current_id = current_replace_ids
4636                    .as_ref()
4637                    .and_then(|ids| ids.get(&key))
4638                    .copied();
4639
4640                if current_id.is_none() || current_id != eligible_replaces.get(&key).copied() {
4641                    return None;
4642                }
4643            }
4644
4645            state
4646                .pending_replace_awaits_reconciliation(&client_order_id, &bet_id)
4647                .then_some((client_order_id, strategy_id, bet_id, report))
4648        })
4649        .collect::<Vec<_>>();
4650
4651    for (client_order_id, strategy_id, bet_id, report) in non_actionable_replaces {
4652        if report.order_status.is_closed() {
4653            if report.client_order_id == Some(client_order_id) {
4654                state.take_pending_replace(client_order_id, &bet_id);
4655            }
4656
4657            state.retain_terminal_order(client_order_id, &bet_id);
4658            continue;
4659        }
4660
4661        state.take_pending_replace(client_order_id, &bet_id);
4662        state.mark_order_active(&client_order_id, &bet_id);
4663        updates.push(OrderEventAny::ModifyRejected(OrderModifyRejected::new(
4664            emitter.trader_id(),
4665            strategy_id,
4666            report.instrument_id,
4667            client_order_id,
4668            Ustr::from("Original bet remained executable after ambiguous replace"),
4669            UUID4::new(),
4670            report.ts_last,
4671            report.ts_init,
4672            true,
4673            Some(report.venue_order_id),
4674            Some(emitter.account_id()),
4675        )));
4676    }
4677
4678    updates
4679}
4680
4681fn report_correlation(
4682    state: &OcmState,
4683    report: &OrderStatusReport,
4684) -> Option<(ClientOrderId, StrategyId)> {
4685    let client_order_id = report
4686        .client_order_id
4687        .or_else(|| state.client_order_id_by_venue_order_id(report.venue_order_id.as_str()))?;
4688    let strategy_id = state.order_strategy_id(&client_order_id)?;
4689    Some((client_order_id, strategy_id))
4690}
4691
4692#[derive(Default)]
4693struct ReplacedLegFills {
4694    matched: Quantity,
4695    voided: Quantity,
4696    notional: Option<Decimal>,
4697}
4698
4699impl ReplacedLegFills {
4700    fn accumulate(&mut self, matched: Quantity, avg_px: Option<Decimal>) {
4701        if matched.is_zero() {
4702            return;
4703        }
4704
4705        let notional = match (self.notional, avg_px) {
4706            (Some(notional), Some(avg_px)) => Some(notional + matched.as_decimal() * avg_px),
4707            // A leg with no average price leaves the weighted average unknown for
4708            // the whole history; only a first leg can initialize the notional.
4709            (None, Some(avg_px)) if self.matched.is_zero() => Some(matched.as_decimal() * avg_px),
4710            _ => None,
4711        };
4712
4713        self.matched = self.matched + matched;
4714        self.notional = notional;
4715    }
4716
4717    fn accumulate_voided(&mut self, voided: Quantity) {
4718        self.voided = self.voided + voided;
4719    }
4720
4721    fn fold(self, report: &mut OrderStatusReport, quantity_already_logical: bool) {
4722        if self.matched.is_zero() && self.voided.is_zero() {
4723            return;
4724        }
4725
4726        // A confirmed reduction on the successor already stores the logical
4727        // quantity, which includes every replaced leg's matched and voided size.
4728        if !quantity_already_logical {
4729            report.quantity = report.quantity + self.matched + self.voided;
4730        }
4731
4732        let mut totals = self;
4733        totals.accumulate(report.filled_qty, report.avg_px);
4734        report.filled_qty = totals.matched;
4735        report.avg_px = totals
4736            .notional
4737            .map(|notional| notional / totals.matched.as_decimal());
4738        // An executable bet with cumulative matched quantity is partially
4739        // filled; the engine's Accepted branch applies no fills.
4740        if report.order_status == OrderStatus::Accepted && !report.filled_qty.is_zero() {
4741            report.order_status = OrderStatus::PartiallyFilled;
4742        }
4743    }
4744}
4745
4746/// Accumulates matched and voided quantity from replaced Bet legs into their successor's report.
4747///
4748/// A price replacement reports each leg's matched quantity separately, so the
4749/// successor's per-bet totals would read as a fill decrease at the engine. Folding
4750/// the replaced legs into the current Bet's report reconciles the full history.
4751fn accumulate_replaced_leg_fills(
4752    reports: &mut [OrderStatusReport],
4753    voided_quantities: &AHashMap<String, Quantity>,
4754    state: &OcmState,
4755) {
4756    let mut successor_indexes: AHashMap<ClientOrderId, usize> = AHashMap::new();
4757
4758    for (index, report) in reports.iter().enumerate() {
4759        let Some((client_order_id, _)) = report_correlation(state, report) else {
4760            continue;
4761        };
4762
4763        if state.is_current_venue_order_id(&client_order_id, report.venue_order_id.as_str()) {
4764            successor_indexes.insert(client_order_id, index);
4765        }
4766    }
4767
4768    let replaced_fills = replaced_leg_fills_from_reports(reports, voided_quantities, state);
4769
4770    for (client_order_id, fills) in replaced_fills {
4771        let Some(&index) = successor_indexes.get(&client_order_id) else {
4772            continue;
4773        };
4774
4775        let bet_id = reports[index].venue_order_id.as_str().to_string();
4776        let quantity_already_logical = state.reduced_quantity(&bet_id).is_some();
4777        fills.fold(&mut reports[index], quantity_already_logical);
4778    }
4779}
4780
4781fn replaced_leg_fills_from_reports(
4782    reports: &[OrderStatusReport],
4783    voided_quantities: &AHashMap<String, Quantity>,
4784    state: &OcmState,
4785) -> AHashMap<ClientOrderId, ReplacedLegFills> {
4786    let mut fills: AHashMap<ClientOrderId, ReplacedLegFills> = AHashMap::new();
4787
4788    for report in reports {
4789        let bet_id = report.venue_order_id.as_str();
4790        if !state.replaced_venue_order_ids.contains(bet_id) {
4791            continue;
4792        }
4793
4794        if let Some((client_order_id, _)) = report_correlation(state, report) {
4795            let entry = fills.entry(client_order_id).or_default();
4796            entry.accumulate(report.filled_qty, report.avg_px);
4797            if let Some(leg_voided) = voided_quantities.get(bet_id).copied() {
4798                entry.accumulate_voided(leg_voided);
4799            }
4800        }
4801    }
4802
4803    fills
4804}
4805
4806fn replaced_leg_fills_from_candidates(
4807    candidates: &[CurrentOrderSummary],
4808    successor: &CurrentOrderSummary,
4809    state: &OcmState,
4810) -> ReplacedLegFills {
4811    let mut fills = ReplacedLegFills::default();
4812
4813    // An ambiguous customer order ref cannot attribute legs to this order.
4814    let Some(owner_client_order_id) = state
4815        .resolve_order_owner(successor.customer_order_ref.as_deref(), &successor.bet_id)
4816        .and_then(CustomerOrderRefResolution::client_order_id)
4817    else {
4818        return fills;
4819    };
4820
4821    for candidate in candidates {
4822        if candidate.bet_id == successor.bet_id
4823            || !state.replaced_venue_order_ids.contains(&candidate.bet_id)
4824        {
4825            continue;
4826        }
4827
4828        let resolves_to_owner = state
4829            .resolve_order_owner(candidate.customer_order_ref.as_deref(), &candidate.bet_id)
4830            .and_then(CustomerOrderRefResolution::client_order_id)
4831            .is_some_and(|client_order_id| client_order_id == owner_client_order_id);
4832        if !resolves_to_owner {
4833            continue;
4834        }
4835
4836        let matched = candidate.size_matched.unwrap_or(Decimal::ZERO);
4837        match parse_betfair_quantity(matched) {
4838            Ok(matched) => fills.accumulate(matched, candidate.average_price_matched),
4839            Err(e) => {
4840                log::warn!(
4841                    "Skipping replaced leg {} with unparsable matched quantity {matched}: {e}",
4842                    candidate.bet_id,
4843                );
4844            }
4845        }
4846
4847        let voided = candidate.size_voided.unwrap_or(Decimal::ZERO);
4848        match parse_betfair_quantity(voided) {
4849            Ok(voided) => fills.accumulate_voided(voided),
4850            Err(e) => {
4851                log::warn!(
4852                    "Skipping replaced leg {} with unparsable voided quantity {voided}: {e}",
4853                    candidate.bet_id,
4854                );
4855            }
4856        }
4857    }
4858
4859    fills
4860}
4861
4862fn resolve_query_order_report(
4863    order: &CurrentOrderSummary,
4864    report: &mut OrderStatusReport,
4865    fallback_client_order_id: ClientOrderId,
4866    state: &mut OcmState,
4867    emitter: &ExecutionEventEmitter,
4868) -> Option<OrderEventAny> {
4869    let owner = state.resolve_order_owner(
4870        order.customer_order_ref.as_deref(),
4871        report.venue_order_id.as_str(),
4872    );
4873
4874    if let Some(owner) = owner {
4875        report.client_order_id = owner.client_order_id();
4876    }
4877
4878    let update = report_correlation(state, report).and_then(|(client_order_id, strategy_id)| {
4879        resolve_pending_replace_report(report, state, emitter, client_order_id, strategy_id)
4880            .map(|(update, _)| update)
4881    });
4882
4883    if report.client_order_id.is_none() && owner != Some(CustomerOrderRefResolution::Ambiguous) {
4884        report.client_order_id = Some(fallback_client_order_id);
4885    }
4886    update
4887}
4888
4889fn resolve_pending_replace_report(
4890    report: &OrderStatusReport,
4891    state: &mut OcmState,
4892    emitter: &ExecutionEventEmitter,
4893    client_order_id: ClientOrderId,
4894    strategy_id: StrategyId,
4895) -> Option<(OrderEventAny, String)> {
4896    let bet_id = report.venue_order_id.to_string();
4897    let (quantity, old_bet_id) =
4898        state.promote_pending_replace(&client_order_id, &bet_id, report.quantity)?;
4899
4900    // The report keeps its per-bet quantity; `accumulate_replaced_leg_fills`
4901    // folds the replacement history into the totals the engine reconciles.
4902    if report.order_status.is_closed() {
4903        state.retain_terminal_order(client_order_id, &bet_id);
4904    }
4905
4906    let update = make_reconciled_update(
4907        emitter,
4908        report,
4909        client_order_id,
4910        strategy_id,
4911        quantity,
4912        report.price,
4913    );
4914    Some((update, old_bet_id))
4915}
4916
4917fn resolve_pending_reduction_from_reconciliation(
4918    state: &mut OcmState,
4919    active_quantities: &AHashMap<String, Quantity>,
4920    client_order_id: &ClientOrderId,
4921    bet_id: &str,
4922    replaced_matched: Quantity,
4923    replaced_voided: Quantity,
4924) -> Option<Quantity> {
4925    let active_quantity =
4926        active_quantities.get(bet_id).copied()? + replaced_matched + replaced_voided;
4927    state.confirm_pending_reduction(client_order_id, bet_id, active_quantity)
4928}
4929
4930fn make_reconciled_update(
4931    emitter: &ExecutionEventEmitter,
4932    report: &OrderStatusReport,
4933    client_order_id: ClientOrderId,
4934    strategy_id: StrategyId,
4935    quantity: Quantity,
4936    price: Option<Price>,
4937) -> OrderEventAny {
4938    let updated = OrderUpdated::new(
4939        emitter.trader_id(),
4940        strategy_id,
4941        report.instrument_id,
4942        client_order_id,
4943        quantity,
4944        UUID4::new(),
4945        report.ts_last,
4946        report.ts_init,
4947        true,
4948        Some(report.venue_order_id),
4949        Some(report.account_id),
4950        price,
4951        None,
4952        None,
4953        false,
4954    );
4955    OrderEventAny::Updated(updated)
4956}
4957
4958fn current_order_active_quantity(order: &CurrentOrderSummary) -> anyhow::Result<Quantity> {
4959    let active = order.size_matched.unwrap_or(Decimal::ZERO)
4960        + order.size_remaining.unwrap_or(Decimal::ZERO)
4961        + order.size_voided.unwrap_or(Decimal::ZERO);
4962    parse_betfair_quantity(active)
4963}
4964
4965/// Paginates `list_current_orders` into `FillReport`s without touching the
4966/// engine cache, so it is callable from any tokio task.
4967#[expect(
4968    clippy::too_many_arguments,
4969    reason = "report context and session refresh state remain explicit at the HTTP boundary"
4970)]
4971async fn fetch_fill_reports_http(
4972    http_client: &Arc<BetfairHttpClient>,
4973    account_id: AccountId,
4974    currency: Currency,
4975    ts_init: UnixNanos,
4976    market_ids: Option<Vec<String>>,
4977    date_range: Option<TimeRange>,
4978    filter: Option<&GenerateFillReports>,
4979    ocm_state: &Arc<Mutex<OcmState>>,
4980    stream_session: StreamSession<'_>,
4981    session_refresh: &mut SessionRefresh,
4982) -> anyhow::Result<Vec<FillReport>> {
4983    let mut orders = fetch_fill_orders_http(
4984        http_client,
4985        market_ids,
4986        date_range,
4987        stream_session,
4988        session_refresh,
4989    )
4990    .await?;
4991
4992    if let Some(filter) = filter {
4993        retain_fill_orders(&mut orders, filter);
4994    }
4995
4996    finish_fill_reports(&orders, ocm_state, account_id, currency, ts_init)
4997}
4998
4999fn fill_report_date_range(filter: &GenerateFillReports) -> Option<TimeRange> {
5000    (filter.start.is_some() || filter.end.is_some()).then(|| TimeRange {
5001        from: filter.start.map(|start| start.to_rfc3339()),
5002        to: filter.end.map(|end| end.to_rfc3339()),
5003    })
5004}
5005
5006fn retain_fill_orders(orders: &mut Vec<CurrentOrderSummary>, filter: &GenerateFillReports) {
5007    orders.retain(|order| {
5008        filter
5009            .venue_order_id
5010            .is_none_or(|venue_order_id| venue_order_id.as_str() == order.bet_id)
5011            && filter.instrument_id.is_none_or(|instrument_id| {
5012                make_instrument_id(&order.market_id, order.selection_id, order.handicap)
5013                    == instrument_id
5014            })
5015    });
5016}
5017
5018fn finish_fill_reports(
5019    orders: &[CurrentOrderSummary],
5020    ocm_state: &Arc<Mutex<OcmState>>,
5021    account_id: AccountId,
5022    currency: Currency,
5023    ts_init: UnixNanos,
5024) -> anyhow::Result<Vec<FillReport>> {
5025    let mut state = ocm_state.lock();
5026    let customer_order_refs = state.customer_order_refs.clone();
5027    let mut fill_tracker = state.fill_tracker.clone();
5028    let reports = build_incremental_fill_reports(
5029        orders,
5030        &mut fill_tracker,
5031        &customer_order_refs,
5032        account_id,
5033        currency,
5034        ts_init,
5035    )?;
5036    state.fill_tracker = fill_tracker;
5037    Ok(reports)
5038}
5039
5040async fn fetch_fill_orders_http(
5041    http_client: &Arc<BetfairHttpClient>,
5042    market_ids: Option<Vec<String>>,
5043    date_range: Option<TimeRange>,
5044    stream_session: StreamSession<'_>,
5045    session_refresh: &mut SessionRefresh,
5046) -> anyhow::Result<Vec<CurrentOrderSummary>> {
5047    let mut orders = Vec::new();
5048    let market_id_batches = list_current_orders_market_id_batches(market_ids);
5049    let merge_batches = market_id_batches.len() > 1;
5050
5051    for market_ids in market_id_batches {
5052        let mut from_record: u32 = 0;
5053
5054        loop {
5055            let params = ListCurrentOrdersParams {
5056                bet_ids: None,
5057                market_ids: market_ids.clone(),
5058                order_projection: Some(OrderProjection::All),
5059                customer_order_refs: None,
5060                customer_strategy_refs: None,
5061                date_range: date_range.clone(),
5062                order_by: Some(OrderBy::ByMatchTime),
5063                sort_dir: Some(SortDir::EarliestToLatest),
5064                from_record: (from_record > 0).then_some(from_record),
5065                record_count: None,
5066            };
5067
5068            let response = list_current_orders_with_retry(
5069                http_client,
5070                &params,
5071                stream_session,
5072                session_refresh,
5073            )
5074            .await?;
5075            let page_size = response.current_orders.len() as u32;
5076
5077            if response.more_available && page_size == 0 {
5078                anyhow::bail!("listCurrentOrders returned an empty page with moreAvailable=true");
5079            }
5080
5081            orders.extend(response.current_orders);
5082
5083            if !response.more_available {
5084                break;
5085            }
5086
5087            from_record += page_size;
5088        }
5089    }
5090
5091    if merge_batches {
5092        orders.sort_by_cached_key(current_order_match_sort_key);
5093    }
5094
5095    Ok(orders)
5096}
5097
5098const MAX_LIST_CURRENT_ORDERS_MARKET_IDS: usize = 250;
5099
5100fn list_current_orders_filter_markets(
5101    market_ids: Option<Vec<String>>,
5102    order_projection: Option<OrderProjection>,
5103) -> ListCurrentOrdersParams {
5104    ListCurrentOrdersParams {
5105        bet_ids: None,
5106        market_ids,
5107        order_projection,
5108        customer_order_refs: None,
5109        customer_strategy_refs: None,
5110        date_range: None,
5111        order_by: None,
5112        sort_dir: None,
5113        from_record: None,
5114        record_count: None,
5115    }
5116}
5117
5118fn list_current_orders_market_id_batches(
5119    market_ids: Option<Vec<String>>,
5120) -> Vec<Option<Vec<String>>> {
5121    match market_ids {
5122        Some(ids) if ids.len() > MAX_LIST_CURRENT_ORDERS_MARKET_IDS => ids
5123            .chunks(MAX_LIST_CURRENT_ORDERS_MARKET_IDS)
5124            .map(|chunk| Some(chunk.to_vec()))
5125            .collect(),
5126        ids => vec![ids],
5127    }
5128}
5129
5130fn current_order_match_sort_key(
5131    order: &CurrentOrderSummary,
5132) -> (Option<UnixNanos>, Option<UnixNanos>, String) {
5133    let matched = order
5134        .matched_date
5135        .as_deref()
5136        .and_then(|date| parse_betfair_timestamp(date).ok());
5137    let placed = parse_betfair_timestamp(&order.placed_date).ok();
5138    (matched, placed, order.bet_id.clone())
5139}
5140
5141fn build_incremental_fill_reports(
5142    orders: &[CurrentOrderSummary],
5143    fill_tracker: &mut FillTracker,
5144    customer_order_refs: &AHashMap<String, CustomerOrderRefResolution>,
5145    account_id: AccountId,
5146    currency: Currency,
5147    ts_init: UnixNanos,
5148) -> anyhow::Result<Vec<FillReport>> {
5149    let mut reports = Vec::new();
5150
5151    for order in orders {
5152        let size_matched = order.size_matched.unwrap_or(Decimal::ZERO);
5153        let size_voided = order.size_voided.unwrap_or(Decimal::ZERO);
5154        let gross_matched = size_matched + size_voided;
5155        if gross_matched == Decimal::ZERO {
5156            continue;
5157        }
5158
5159        parse_betfair_timestamp(&order.placed_date).map_err(|e| {
5160            anyhow::anyhow!("Failed to parse fill report for {}: {e}", order.bet_id)
5161        })?;
5162
5163        if fill_tracker.has_pending_price_restatement(
5164            &order.bet_id,
5165            size_matched,
5166            size_voided,
5167            order.average_price_matched,
5168        ) {
5169            continue;
5170        }
5171
5172        let has_applied_fill_lots = fill_tracker.has_fill_lots(&order.bet_id);
5173        let cumulative = if has_applied_fill_lots {
5174            gross_matched
5175        } else {
5176            size_matched
5177        };
5178        let incremental_fill = if has_applied_fill_lots && size_voided > Decimal::ZERO {
5179            fill_tracker.advance_cumulative_fill_with_voids(
5180                &order.bet_id,
5181                cumulative,
5182                size_voided,
5183                order.average_price_matched,
5184                order.price_size.price,
5185            )
5186        } else {
5187            fill_tracker.advance_cumulative_fill(
5188                &order.bet_id,
5189                cumulative,
5190                order.average_price_matched,
5191                order.price_size.price,
5192            )
5193        };
5194
5195        if !has_applied_fill_lots {
5196            if incremental_fill.is_some() {
5197                fill_tracker.sync_order(
5198                    &order.bet_id,
5199                    gross_matched,
5200                    order.average_price_matched.unwrap_or(Decimal::ZERO),
5201                );
5202            }
5203
5204            fill_tracker.sync_voided_qty(&order.bet_id, size_voided);
5205        }
5206
5207        let Some((trade_id, last_qty, last_px)) = incremental_fill else {
5208            continue;
5209        };
5210
5211        let mut report = parse_current_order_fill_report(
5212            order, account_id, currency, trade_id, last_qty, last_px, ts_init,
5213        )
5214        .map_err(|e| anyhow::anyhow!("Failed to parse fill report for {}: {e}", order.bet_id))?;
5215        if let Some(ref customer_order_ref) = order.customer_order_ref
5216            && let Some(resolution) = customer_order_refs.get(customer_order_ref).copied()
5217        {
5218            report.client_order_id = resolution.client_order_id();
5219        }
5220        reports.push(report);
5221    }
5222
5223    Ok(reports)
5224}
5225
5226struct MassStatusSnapshot {
5227    client_id: ClientId,
5228    account_id: AccountId,
5229    currency: Currency,
5230    ts_init: UnixNanos,
5231    order_reports: Vec<OrderStatusReport>,
5232    active_quantities: AHashMap<String, Quantity>,
5233    voided_quantities: AHashMap<String, Quantity>,
5234    fill_orders: Vec<CurrentOrderSummary>,
5235    account_state: Option<AccountState>,
5236}
5237
5238impl MassStatusSnapshot {
5239    fn build(
5240        self,
5241        state: &mut OcmState,
5242        emitter: &ExecutionEventEmitter,
5243    ) -> anyhow::Result<(ExecutionMassStatus, Vec<OrderEventAny>)> {
5244        let mut order_reports = self.order_reports;
5245
5246        let updates = resolve_pending_modifies_in_state(
5247            &mut order_reports,
5248            &self.active_quantities,
5249            &self.voided_quantities,
5250            state,
5251            emitter,
5252            None,
5253        );
5254        let fill_reports = build_incremental_fill_reports(
5255            &self.fill_orders,
5256            &mut state.fill_tracker,
5257            &state.customer_order_refs,
5258            self.account_id,
5259            self.currency,
5260            self.ts_init,
5261        )?;
5262
5263        let mut mass_status = ExecutionMassStatus::new(
5264            self.client_id,
5265            self.account_id,
5266            *BETFAIR_VENUE,
5267            self.ts_init,
5268            None,
5269        );
5270        mass_status.add_order_reports(order_reports);
5271        mass_status.add_fill_reports(fill_reports);
5272        Ok((mass_status, updates))
5273    }
5274}
5275
5276fn retain_snapshot_fill_orders(
5277    orders: &mut Vec<CurrentOrderSummary>,
5278    start: Option<UnixNanos>,
5279    end: Option<UnixNanos>,
5280) -> anyhow::Result<()> {
5281    let mut eligible = Vec::with_capacity(orders.len());
5282    for order in orders.drain(..) {
5283        let Some(date) = &order.matched_date else {
5284            continue;
5285        };
5286
5287        let matched = parse_betfair_timestamp(date)
5288            .map_err(|e| anyhow::anyhow!("Failed to parse match time for {}: {e}", order.bet_id))?;
5289        if start.is_none_or(|start| matched >= start) && end.is_none_or(|end| matched <= end) {
5290            eligible.push(order);
5291        }
5292    }
5293
5294    eligible.sort_by_cached_key(current_order_match_sort_key);
5295    *orders = eligible;
5296    Ok(())
5297}
5298
5299async fn wait_for_generation_change(
5300    state_rx: &mut tokio::sync::watch::Receiver<u64>,
5301    generation: u64,
5302) {
5303    while *state_rx.borrow_and_update() == generation {
5304        if state_rx.changed().await.is_err() {
5305            return;
5306        }
5307    }
5308}
5309
5310/// Waits until the gate's halt state equals `expected`.
5311///
5312/// Subscribes before the first read so a transition landing between the two is
5313/// observed rather than missed. The generation channel is used only as an edge
5314/// notification; `is_halted` remains the authoritative read.
5315async fn wait_for_reconciliation_state(gate: &ReconciliationGate, expected: bool) {
5316    let mut state_rx = gate.subscribe();
5317
5318    while gate.is_halted() != expected {
5319        if state_rx.changed().await.is_err() {
5320            return;
5321        }
5322    }
5323}
5324
5325#[expect(
5326    clippy::too_many_arguments,
5327    reason = "recovery keeps venue clients, account context, and generation inputs explicit"
5328)]
5329async fn attempt_post_reconnect_recovery(
5330    http_client: &Arc<BetfairHttpClient>,
5331    stream_client: &Arc<BetfairStreamClient>,
5332    app_key: &str,
5333    client_id: ClientId,
5334    account_id: AccountId,
5335    currency: Currency,
5336    clock: &'static AtomicTime,
5337    market_ids: Option<Vec<String>>,
5338    lookback_mins: u64,
5339    ocm_state: &Arc<Mutex<OcmState>>,
5340) -> anyhow::Result<MassStatusSnapshot> {
5341    let mut session_refresh = SessionRefresh::default();
5342    match http_client.keep_alive_with_token().await {
5343        Ok(_) => session_refresh.refreshed = true,
5344        Err(ref e) if e.is_login_failed() => {
5345            log::warn!("Session expired on reconnect, attempting re-login: {e}");
5346            http_client.reconnect_with_token().await?;
5347            session_refresh.refreshed = true;
5348            session_refresh.replaced = true;
5349        }
5350        Err(e) => log::warn!(
5351            "Keep-alive failed on reconnect; continuing recovery with the retained session: {e}",
5352        ),
5353    }
5354
5355    let stream_session = StreamSession {
5356        client: Some(stream_client),
5357        app_key,
5358    };
5359
5360    if session_refresh.refreshed {
5361        stream_session.publish(http_client).await;
5362    }
5363
5364    let account_state = match http_client
5365        .send_accounts::<AccountFundsResponse, _>(METHOD_GET_ACCOUNT_FUNDS, serde_json::json!({}))
5366        .await
5367    {
5368        Ok(funds) => {
5369            let ts_init = clock.get_time_ns();
5370            match parse_account_state(&funds, account_id, currency, ts_init, ts_init) {
5371                Ok(state) => Some(state),
5372                Err(e) => {
5373                    log::warn!("Failed to parse account state on reconnect: {e}");
5374                    None
5375                }
5376            }
5377        }
5378        Err(e) => {
5379            log::warn!("Failed to fetch account state on reconnect: {e}");
5380            None
5381        }
5382    };
5383
5384    let result = fetch_post_reconnect_mass_status(
5385        http_client,
5386        client_id,
5387        account_id,
5388        currency,
5389        clock,
5390        market_ids,
5391        lookback_mins,
5392        ocm_state,
5393        stream_session,
5394        &mut session_refresh,
5395    )
5396    .await;
5397    apply_stream_session_refresh(
5398        http_client.as_ref(),
5399        Some(stream_client),
5400        app_key,
5401        session_refresh,
5402    )
5403    .await;
5404    result.map(|mut result| {
5405        result.account_state = account_state;
5406        result
5407    })
5408}
5409
5410/// Fetches the REST inputs for an [`ExecutionMassStatus`] over `lookback_mins` of history.
5411#[expect(clippy::too_many_arguments)]
5412async fn fetch_post_reconnect_mass_status(
5413    http_client: &Arc<BetfairHttpClient>,
5414    client_id: ClientId,
5415    account_id: AccountId,
5416    currency: Currency,
5417    clock: &'static AtomicTime,
5418    market_ids: Option<Vec<String>>,
5419    lookback_mins: u64,
5420    ocm_state: &Arc<Mutex<OcmState>>,
5421    stream_session: StreamSession<'_>,
5422    session_refresh: &mut SessionRefresh,
5423) -> anyhow::Result<MassStatusSnapshot> {
5424    let ts_now = clock.get_time_ns();
5425    let start = ts_now.saturating_sub(DurationNanos::try_from_mins(lookback_mins)?);
5426
5427    let mut fetched_orders = fetch_order_status_reports_snapshot_http(
5428        http_client,
5429        account_id,
5430        ts_now,
5431        market_ids,
5432        false,
5433        ocm_state,
5434        stream_session,
5435        session_refresh,
5436    )
5437    .await?;
5438    assign_report_owners(&mut fetched_orders.reports, &ocm_state.lock());
5439    retain_snapshot_fill_orders(&mut fetched_orders.orders, Some(start), Some(ts_now))?;
5440    Ok(MassStatusSnapshot {
5441        client_id,
5442        account_id,
5443        currency,
5444        ts_init: ts_now,
5445        order_reports: fetched_orders.reports,
5446        active_quantities: fetched_orders.active_quantities,
5447        voided_quantities: fetched_orders.voided_quantities,
5448        fill_orders: fetched_orders.orders,
5449        account_state: None,
5450    })
5451}
5452
5453fn list_current_orders_filter_bet_id(bet_id: String) -> ListCurrentOrdersParams {
5454    ListCurrentOrdersParams {
5455        bet_ids: Some(vec![bet_id]),
5456        market_ids: None,
5457        order_projection: None,
5458        customer_order_refs: None,
5459        customer_strategy_refs: None,
5460        date_range: None,
5461        order_by: None,
5462        sort_dir: None,
5463        from_record: None,
5464        record_count: None,
5465    }
5466}
5467
5468fn list_current_orders_filter_ref(customer_order_ref: String) -> ListCurrentOrdersParams {
5469    ListCurrentOrdersParams {
5470        bet_ids: None,
5471        market_ids: None,
5472        order_projection: None,
5473        customer_order_refs: Some(vec![customer_order_ref]),
5474        customer_strategy_refs: None,
5475        date_range: None,
5476        order_by: None,
5477        sort_dir: None,
5478        from_record: None,
5479        record_count: None,
5480    }
5481}
5482
5483fn extend_unique(
5484    candidates: &mut Vec<CurrentOrderSummary>,
5485    seen: &mut AHashSet<String>,
5486    orders: Vec<CurrentOrderSummary>,
5487) {
5488    for order in orders {
5489        if seen.insert(order.bet_id.clone()) {
5490            candidates.push(order);
5491        }
5492    }
5493}
5494
5495fn select_order_for_query(
5496    orders: &[CurrentOrderSummary],
5497    expected_instrument_id: InstrumentId,
5498    expected_client_order_id: ClientOrderId,
5499    expected_venue_order_id: Option<VenueOrderId>,
5500) -> Option<&CurrentOrderSummary> {
5501    let matching: Vec<&CurrentOrderSummary> = orders
5502        .iter()
5503        .filter(|o| {
5504            make_instrument_id(&o.market_id, o.selection_id, o.handicap) == expected_instrument_id
5505        })
5506        .collect();
5507
5508    let candidates: Vec<&CurrentOrderSummary> = if matching.is_empty() {
5509        // No instrument match: accept only an exact venue_order_id hit
5510        // (pre-existing orders without a recognizable customer_order_ref).
5511        // A lone foreign-instrument candidate is not enough, since a 32-char
5512        // customer_order_ref collision can surface a single unrelated bet.
5513        if let Some(vid) = expected_venue_order_id
5514            && let Some(order) = orders.iter().find(|o| o.bet_id == vid.as_str())
5515        {
5516            return Some(order);
5517        }
5518        log::warn!(
5519            "Betfair query_order returned {} orders for client_order_id={expected_client_order_id}, none matching instrument {expected_instrument_id}; skipping to avoid cross-instrument reconciliation",
5520            orders.len(),
5521        );
5522        return None;
5523    } else {
5524        matching
5525    };
5526
5527    // Prefer EXECUTABLE so a live replacement wins over a cancelled
5528    // predecessor sharing the same customer_order_ref.
5529    let executable: Vec<&CurrentOrderSummary> = candidates
5530        .iter()
5531        .copied()
5532        .filter(|o| o.status == BetfairOrderStatus::Executable)
5533        .collect();
5534
5535    let pool = if executable.is_empty() {
5536        candidates
5537    } else {
5538        executable
5539    };
5540
5541    // Tiebreaker: most recently placed bet. Picks the replacement over the
5542    // predecessor even when both are already terminal by poll time.
5543    pool.into_iter()
5544        .max_by(|a, b| a.placed_date.cmp(&b.placed_date))
5545}
5546
5547async fn list_current_orders_with_retry(
5548    http_client: &Arc<BetfairHttpClient>,
5549    params: &ListCurrentOrdersParams,
5550    stream_session: StreamSession<'_>,
5551    session_refresh: &mut SessionRefresh,
5552) -> anyhow::Result<CurrentOrderSummaryReport> {
5553    send_betting_with_retry(
5554        http_client,
5555        METHOD_LIST_CURRENT_ORDERS,
5556        params,
5557        stream_session,
5558        session_refresh,
5559    )
5560    .await
5561}
5562
5563async fn send_betting_with_retry<T: serde::de::DeserializeOwned, P: serde::Serialize>(
5564    http_client: &Arc<BetfairHttpClient>,
5565    method: &str,
5566    params: &P,
5567    stream_session: StreamSession<'_>,
5568    session_refresh: &mut SessionRefresh,
5569) -> anyhow::Result<T> {
5570    const RATE_LIMIT_RETRY_DELAY_SECS: u64 = 5;
5571
5572    match http_client.send_betting(method, params).await {
5573        Ok(r) => Ok(r),
5574        Err(e) if e.is_session_error() || e.is_rate_limit_error() => {
5575            if e.is_rate_limit_error() {
5576                log::warn!("Rate limited, retrying in {RATE_LIMIT_RETRY_DELAY_SECS}s");
5577                tokio::time::sleep(tokio::time::Duration::from_secs(
5578                    RATE_LIMIT_RETRY_DELAY_SECS,
5579                ))
5580                .await;
5581            } else {
5582                log::warn!("Session error, refreshing session");
5583
5584                let refreshed = match http_client.keep_alive_with_token().await {
5585                    Ok(_) => Some(false),
5586                    Err(_) => http_client.reconnect_with_token().await.ok().map(|_| true),
5587                };
5588
5589                if let Some(session_replaced) = refreshed {
5590                    session_refresh.refreshed = true;
5591                    session_refresh.replaced |= session_replaced;
5592                    stream_session.publish(http_client).await;
5593                }
5594            }
5595            http_client
5596                .send_betting(method, params)
5597                .await
5598                .map_err(|e| anyhow::anyhow!("{e}"))
5599        }
5600        Err(e) => Err(anyhow::anyhow!("{e}")),
5601    }
5602}
5603
5604#[derive(Default)]
5605struct SessionRefresh {
5606    refreshed: bool,
5607    replaced: bool,
5608}
5609
5610#[derive(Clone, Copy)]
5611struct StreamSession<'a> {
5612    client: Option<&'a Arc<BetfairStreamClient>>,
5613    app_key: &'a str,
5614}
5615
5616impl StreamSession<'_> {
5617    async fn publish(self, http_client: &BetfairHttpClient) {
5618        let Some(client) = self.client else {
5619            return;
5620        };
5621
5622        let _ = http_client
5623            .with_session_token(|token| {
5624                client.update_auth(self.app_key, token.clone());
5625            })
5626            .await;
5627    }
5628}
5629
5630async fn apply_stream_session_refresh(
5631    http_client: &BetfairHttpClient,
5632    stream_client: Option<&Arc<BetfairStreamClient>>,
5633    app_key: &str,
5634    session_refresh: SessionRefresh,
5635) {
5636    if !session_refresh.refreshed {
5637        return;
5638    }
5639    let Some(stream_client) = stream_client else {
5640        return;
5641    };
5642
5643    let _ = http_client
5644        .with_session_token(|token| {
5645            stream_client.update_auth(app_key, token.clone());
5646            if session_refresh.replaced {
5647                let _ = stream_client.request_reconnect();
5648            }
5649        })
5650        .await;
5651}
5652
5653// Claims and emits the HTTP place acceptance while holding the `OcmState` lock. The OCM
5654// handler emits under the same lock, so a racing OCM fill cannot enqueue ahead of this
5655// acceptance. No-op if acceptance was already claimed.
5656fn emit_http_accept_if_claimed(
5657    ocm_state: &Arc<Mutex<OcmState>>,
5658    client_order_id: &ClientOrderId,
5659    venue_order_id: VenueOrderId,
5660    emit: impl FnOnce(),
5661) {
5662    let mut state = ocm_state.lock();
5663
5664    if state.claim_acceptance(*client_order_id, venue_order_id) {
5665        emit();
5666    }
5667}
5668
5669#[expect(
5670    clippy::too_many_arguments,
5671    reason = "order identity and reconciliation state remain explicit at the replace failure boundary"
5672)]
5673fn emit_replace_failure(
5674    ocm_state: &Arc<Mutex<OcmState>>,
5675    emitter: &ExecutionEventEmitter,
5676    clock: &AtomicTime,
5677    strategy_id: StrategyId,
5678    instrument_id: InstrumentId,
5679    client_order_id: ClientOrderId,
5680    venue_order_id: VenueOrderId,
5681    old_bet_id: &str,
5682    reason: &str,
5683    failure: &CommandFailure,
5684    causation_id: UUID4,
5685) {
5686    let ts_event = clock.get_time_ns();
5687    let old_terminal = {
5688        let mut state = ocm_state.lock();
5689        let old_terminal = state.terminal_orders.contains(old_bet_id);
5690        let Some(_) = state.take_pending_replace(client_order_id, old_bet_id) else {
5691            return;
5692        };
5693
5694        if old_terminal {
5695            state.retain_terminal_order(client_order_id, old_bet_id);
5696        }
5697        old_terminal
5698    };
5699
5700    if matches!(failure, CommandFailure::NotSent(_)) {
5701        emitter.emit_order_modify_denied_event(
5702            strategy_id,
5703            instrument_id,
5704            client_order_id,
5705            Some(venue_order_id),
5706            reason,
5707            ts_event,
5708            Some(causation_id),
5709        );
5710    }
5711
5712    if old_terminal {
5713        let canceled = OrderCanceled::new(
5714            emitter.trader_id(),
5715            strategy_id,
5716            instrument_id,
5717            client_order_id,
5718            UUID4::new(),
5719            ts_event,
5720            ts_event,
5721            false,
5722            Some(venue_order_id),
5723            Some(emitter.account_id()),
5724            None,
5725        );
5726        emitter.send_order_event(OrderEventAny::Canceled(canceled));
5727    } else if !matches!(failure, CommandFailure::NotSent(_)) {
5728        emitter.emit_order_modify_rejected_event(
5729            strategy_id,
5730            instrument_id,
5731            client_order_id,
5732            Some(venue_order_id),
5733            reason,
5734            ts_event,
5735            Some(causation_id),
5736        );
5737    }
5738}
5739
5740// Claims and emits a definitive HTTP rejection while holding the same state lock as OCM.
5741fn emit_http_reject_if_unreported(
5742    ocm_state: &Arc<Mutex<OcmState>>,
5743    client_order_id: &ClientOrderId,
5744    reason: &str,
5745    emit: impl FnOnce(),
5746) {
5747    let mut state = ocm_state.lock();
5748
5749    if state.is_accepted(client_order_id) {
5750        log::debug!(
5751            "Suppressing late HTTP rejection for {client_order_id}: OCM already reported order state ({reason})"
5752        );
5753        return;
5754    }
5755
5756    emit();
5757    state.remove_order_correlation(client_order_id);
5758}
5759
5760fn order_customer_ref() -> String {
5761    UUID4::new().to_string().replace('-', "")
5762}
5763
5764fn classify_http_error(error: &BetfairHttpError) -> CommandFailure {
5765    let reason = error.to_string();
5766
5767    if error.is_order_ambiguous() {
5768        CommandFailure::ambiguous(reason)
5769    } else if matches!(
5770        error,
5771        BetfairHttpError::MissingCredentials
5772            | BetfairHttpError::LoginFailed { .. }
5773            | BetfairHttpError::JsonError(_)
5774            | BetfairHttpError::InvalidConfiguration(_)
5775    ) {
5776        CommandFailure::not_sent(reason)
5777    } else {
5778        CommandFailure::venue_rejected(reason)
5779    }
5780}
5781
5782fn single_instruction_report<T>(reports: Option<&[T]>) -> Option<&T> {
5783    match reports? {
5784        [report] => Some(report),
5785        _ => None,
5786    }
5787}
5788
5789fn stream_active_quantity(uo: &UnmatchedOrder) -> Option<Quantity> {
5790    let active = uo.sm.unwrap_or(Decimal::ZERO)
5791        + uo.sr.unwrap_or(Decimal::ZERO)
5792        + uo.sv.unwrap_or(Decimal::ZERO);
5793    parse_betfair_quantity(active).ok()
5794}
5795
5796fn classify_execution_report<F>(
5797    status: ExecutionReportStatus,
5798    error_code: Option<ExecutionReportErrorCode>,
5799    instruction_result: Option<Result<(), CommandFailure>>,
5800    report_reason: F,
5801) -> Result<(), CommandFailure>
5802where
5803    F: FnOnce() -> String,
5804{
5805    match (status, instruction_result) {
5806        (ExecutionReportStatus::Timeout, _) => Err(CommandFailure::ambiguous(report_reason())),
5807        (ExecutionReportStatus::Failure, Some(Ok(()))) => {
5808            Err(CommandFailure::ambiguous(report_reason()))
5809        }
5810        (_, Some(result)) => result,
5811        (ExecutionReportStatus::Failure, None)
5812            if execution_error_is_venue_rejection(error_code) =>
5813        {
5814            Err(CommandFailure::venue_rejected(report_reason()))
5815        }
5816        (
5817            ExecutionReportStatus::Success
5818            | ExecutionReportStatus::Failure
5819            | ExecutionReportStatus::ProcessedWithErrors,
5820            None,
5821        ) => Err(CommandFailure::ambiguous(report_reason())),
5822    }
5823}
5824
5825fn execution_error_is_venue_rejection(error_code: Option<ExecutionReportErrorCode>) -> bool {
5826    matches!(
5827        error_code,
5828        Some(
5829            ExecutionReportErrorCode::InvalidAccountState
5830                | ExecutionReportErrorCode::InvalidWalletStatus
5831                | ExecutionReportErrorCode::InsufficientFunds
5832                | ExecutionReportErrorCode::LossLimitExceeded
5833                | ExecutionReportErrorCode::MarketSuspended
5834                | ExecutionReportErrorCode::MarketNotOpenForBetting
5835                | ExecutionReportErrorCode::InvalidOrder
5836                | ExecutionReportErrorCode::InvalidMarketId
5837                | ExecutionReportErrorCode::PermissionDenied
5838                | ExecutionReportErrorCode::DuplicateBetids
5839                | ExecutionReportErrorCode::NoActionRequired
5840                | ExecutionReportErrorCode::RejectedByRegulator
5841                | ExecutionReportErrorCode::NoChasing
5842                | ExecutionReportErrorCode::RegulatorIsNotAvailable
5843                | ExecutionReportErrorCode::TooManyInstructions
5844                | ExecutionReportErrorCode::InvalidMarketVersion
5845                | ExecutionReportErrorCode::InvalidProfitRatio
5846                | ExecutionReportErrorCode::EventExposureLimitExceeded
5847                | ExecutionReportErrorCode::EventMatchedExposureLimitExceeded
5848                | ExecutionReportErrorCode::EventBlocked
5849        )
5850    )
5851}
5852
5853fn classify_replace_instruction(
5854    report: &ReplaceInstructionReport,
5855    reason: String,
5856) -> Result<(), CommandFailure> {
5857    classify_instruction_report(report.status, report.error_code, false, || reason.clone())?;
5858
5859    let Some(cancel) = &report.cancel_instruction_report else {
5860        return Err(CommandFailure::ambiguous(reason));
5861    };
5862    classify_instruction_report(cancel.status, cancel.error_code, false, || reason.clone())?;
5863
5864    let Some(place) = &report.place_instruction_report else {
5865        return Err(CommandFailure::ambiguous(reason));
5866    };
5867    classify_instruction_report(place.status, place.error_code, false, || reason)
5868}
5869
5870fn classify_instruction_report<F>(
5871    status: InstructionReportStatus,
5872    error_code: Option<InstructionReportErrorCode>,
5873    bet_taken_is_success: bool,
5874    reason: F,
5875) -> Result<(), CommandFailure>
5876where
5877    F: FnOnce() -> String,
5878{
5879    match status {
5880        InstructionReportStatus::Success => Ok(()),
5881        InstructionReportStatus::Timeout => Err(CommandFailure::ambiguous(reason())),
5882        InstructionReportStatus::Failure
5883            if error_code == Some(InstructionReportErrorCode::BetInProgress) =>
5884        {
5885            Err(CommandFailure::ambiguous(reason()))
5886        }
5887        InstructionReportStatus::Failure
5888            if bet_taken_is_success
5889                && error_code == Some(InstructionReportErrorCode::BetTakenOrLapsed) =>
5890        {
5891            Ok(())
5892        }
5893        InstructionReportStatus::Failure => Err(CommandFailure::venue_rejected(reason())),
5894    }
5895}
5896
5897fn replace_cancelled_without_replacement(report: Option<&ReplaceInstructionReport>) -> bool {
5898    report.is_some_and(|report| {
5899        report.error_code == Some(InstructionReportErrorCode::CancelledNotPlaced)
5900            && report
5901                .cancel_instruction_report
5902                .as_ref()
5903                .is_some_and(|cancel| cancel.status == InstructionReportStatus::Success)
5904            && report
5905                .place_instruction_report
5906                .as_ref()
5907                .is_some_and(|place| place.status == InstructionReportStatus::Failure)
5908    })
5909}
5910
5911fn format_place_instruction_reason(
5912    instruction_report: &PlaceInstructionReport,
5913    report: &PlaceExecutionReport,
5914) -> String {
5915    format_betfair_reason(
5916        instruction_report.error_code,
5917        report_fallback(report.error_code),
5918        "unknown error",
5919    )
5920}
5921
5922fn format_cancel_instruction_reason(
5923    error_code: Option<InstructionReportErrorCode>,
5924    report_error_code: Option<ExecutionReportErrorCode>,
5925) -> String {
5926    format_betfair_reason(
5927        error_code,
5928        report_fallback(report_error_code),
5929        "unknown instruction error",
5930    )
5931}
5932
5933fn format_replace_instruction_reason(
5934    instruction_report: &ReplaceInstructionReport,
5935    report: &ReplaceExecutionReport,
5936) -> String {
5937    let nested_reason = instruction_report
5938        .place_instruction_report
5939        .as_ref()
5940        .and_then(|ir| instruction_fallback(ir.error_code))
5941        .or_else(|| {
5942            instruction_report
5943                .cancel_instruction_report
5944                .as_ref()
5945                .and_then(|ir| instruction_fallback(ir.error_code))
5946        });
5947
5948    format_betfair_reason(
5949        instruction_report.error_code,
5950        nested_reason.or_else(|| report_fallback(report.error_code)),
5951        "unknown instruction error",
5952    )
5953}
5954
5955fn format_betfair_reason(
5956    error_code: Option<impl fmt::Debug>,
5957    fallback: Option<String>,
5958    unknown: &str,
5959) -> String {
5960    error_code
5961        .map(|code| format!("{code:?}"))
5962        .or(fallback)
5963        .unwrap_or_else(|| unknown.to_string())
5964}
5965
5966fn report_fallback(error_code: Option<ExecutionReportErrorCode>) -> Option<String> {
5967    error_code.map(|code| format!("{code:?}"))
5968}
5969
5970fn instruction_fallback(error_code: Option<InstructionReportErrorCode>) -> Option<String> {
5971    error_code.map(|code| format!("{code:?}"))
5972}
5973
5974#[cfg(test)]
5975mod tests {
5976    use std::{cell::RefCell, rc::Rc};
5977
5978    use nautilus_common::{
5979        cache::Cache,
5980        messages::{ExecutionEvent, ExecutionReport},
5981    };
5982    use nautilus_model::{
5983        events::{OrderDenied, OrderSubmitted},
5984        identifiers::{PositionId, StrategyId, TraderId},
5985        instruments::{Instrument, InstrumentAny, stubs::audusd_sim},
5986        orders::builder::OrderTestBuilder,
5987        position::Position,
5988        types::{Money, Price, Quantity},
5989    };
5990    use rstest::rstest;
5991    use rust_decimal::Decimal;
5992    use rust_decimal_macros::dec;
5993
5994    use super::*;
5995    use crate::{
5996        common::{
5997            enums::SegmentType,
5998            testing::{load_test_json, parse_jsonrpc},
5999        },
6000        http::models::CancelInstructionReport,
6001        stream::messages::stream_decode,
6002    };
6003
6004    fn validation_order_builder(order_type: OrderType) -> OrderTestBuilder {
6005        let mut order = OrderTestBuilder::new(order_type);
6006        order
6007            .instrument_id(InstrumentId::from("1.234567-12345-0.0.BETFAIR"))
6008            .quantity(Quantity::from(10));
6009
6010        match order_type {
6011            OrderType::Limit => {
6012                order.price(Price::from("2.0"));
6013            }
6014            OrderType::StopMarket => {
6015                order.trigger_price(Price::from("2.0"));
6016            }
6017            _ => {}
6018        }
6019
6020        order
6021    }
6022
6023    #[rstest]
6024    #[case(OrderType::Limit, TimeInForce::Gtc)]
6025    #[case(OrderType::Market, TimeInForce::AtTheClose)]
6026    fn test_validate_order_accepts_supported_orders(
6027        #[case] order_type: OrderType,
6028        #[case] time_in_force: TimeInForce,
6029    ) {
6030        let order = validation_order_builder(order_type)
6031            .time_in_force(time_in_force)
6032            .build();
6033
6034        assert_eq!(validate_order(&order), Ok(()));
6035    }
6036
6037    #[rstest]
6038    #[case(OrderType::Market, TimeInForce::AtTheClose, true)]
6039    #[case(OrderType::Limit, TimeInForce::AtTheClose, true)]
6040    #[case(OrderType::Limit, TimeInForce::AtTheOpen, true)]
6041    #[case(OrderType::Limit, TimeInForce::Gtc, false)]
6042    fn test_is_sp_order_matches_on_close_time_in_force(
6043        #[case] order_type: OrderType,
6044        #[case] time_in_force: TimeInForce,
6045        #[case] expected: bool,
6046    ) {
6047        let order = validation_order_builder(order_type)
6048            .time_in_force(time_in_force)
6049            .build();
6050
6051        assert_eq!(is_sp_order(&order), expected);
6052    }
6053
6054    #[rstest]
6055    fn test_validate_order_denies_reduce_only() {
6056        let order = validation_order_builder(OrderType::Limit)
6057            .reduce_only(true)
6058            .build();
6059
6060        assert_eq!(
6061            validate_order(&order),
6062            Err(OrderDeniedReason::UnsupportedReduceOnly),
6063        );
6064    }
6065
6066    #[rstest]
6067    fn test_validate_order_denies_unsupported_order_type() {
6068        let order = validation_order_builder(OrderType::StopMarket).build();
6069
6070        assert_eq!(
6071            validate_order(&order),
6072            Err(OrderDeniedReason::UnsupportedOrderType {
6073                order_type: OrderType::StopMarket,
6074            }),
6075        );
6076    }
6077
6078    #[rstest]
6079    fn test_validate_order_denies_unsupported_market_time_in_force() {
6080        let order = validation_order_builder(OrderType::Market)
6081            .time_in_force(TimeInForce::Gtc)
6082            .build();
6083
6084        assert_eq!(
6085            validate_order(&order),
6086            Err(OrderDeniedReason::UnsupportedTimeInForce(TimeInForce::Gtc)),
6087        );
6088    }
6089
6090    #[rstest]
6091    #[case(
6092        ExecutionReportStatus::Success,
6093        None,
6094        Some(Ok(())),
6095        Ok(())
6096    )]
6097    #[case(
6098        ExecutionReportStatus::Success,
6099        None,
6100        None,
6101        Err(CommandFailure::Ambiguous("report reason".to_string()))
6102    )]
6103    #[case(
6104        ExecutionReportStatus::Timeout,
6105        None,
6106        Some(Err(CommandFailure::VenueRejected("instruction reason".to_string()))),
6107        Err(CommandFailure::Ambiguous("report reason".to_string()))
6108    )]
6109    #[case(
6110        ExecutionReportStatus::Failure,
6111        Some(ExecutionReportErrorCode::DuplicateTransaction),
6112        None,
6113        Err(CommandFailure::Ambiguous("report reason".to_string()))
6114    )]
6115    #[case(
6116        ExecutionReportStatus::Failure,
6117        Some(ExecutionReportErrorCode::MarketSuspended),
6118        Some(Ok(())),
6119        Err(CommandFailure::Ambiguous("report reason".to_string()))
6120    )]
6121    #[case(
6122        ExecutionReportStatus::Failure,
6123        Some(ExecutionReportErrorCode::MarketSuspended),
6124        None,
6125        Err(CommandFailure::VenueRejected("report reason".to_string()))
6126    )]
6127    #[case(
6128        ExecutionReportStatus::ProcessedWithErrors,
6129        None,
6130        None,
6131        Err(CommandFailure::Ambiguous("report reason".to_string()))
6132    )]
6133    #[case(
6134        ExecutionReportStatus::ProcessedWithErrors,
6135        None,
6136        Some(Err(CommandFailure::VenueRejected("instruction reason".to_string()))),
6137        Err(CommandFailure::VenueRejected("instruction reason".to_string()))
6138    )]
6139    fn test_classify_execution_report(
6140        #[case] status: ExecutionReportStatus,
6141        #[case] error_code: Option<ExecutionReportErrorCode>,
6142        #[case] instruction_result: Option<Result<(), CommandFailure>>,
6143        #[case] expected: Result<(), CommandFailure>,
6144    ) {
6145        assert_eq!(
6146            classify_execution_report(status, error_code, instruction_result, || {
6147                "report reason".to_string()
6148            }),
6149            expected,
6150        );
6151    }
6152
6153    #[rstest]
6154    #[case(InstructionReportStatus::Success, None, false, Ok(()))]
6155    #[case(
6156        InstructionReportStatus::Timeout,
6157        None,
6158        false,
6159        Err(CommandFailure::Ambiguous("instruction reason".to_string()))
6160    )]
6161    #[case(
6162        InstructionReportStatus::Failure,
6163        Some(InstructionReportErrorCode::BetInProgress),
6164        false,
6165        Err(CommandFailure::Ambiguous("instruction reason".to_string()))
6166    )]
6167    #[case(
6168        InstructionReportStatus::Failure,
6169        Some(InstructionReportErrorCode::BetTakenOrLapsed),
6170        true,
6171        Ok(())
6172    )]
6173    #[case(
6174        InstructionReportStatus::Failure,
6175        Some(InstructionReportErrorCode::BetTakenOrLapsed),
6176        false,
6177        Err(CommandFailure::VenueRejected("instruction reason".to_string()))
6178    )]
6179    #[case(
6180        InstructionReportStatus::Failure,
6181        Some(InstructionReportErrorCode::ErrorInOrder),
6182        false,
6183        Err(CommandFailure::VenueRejected("instruction reason".to_string()))
6184    )]
6185    fn test_classify_instruction_report(
6186        #[case] status: InstructionReportStatus,
6187        #[case] error_code: Option<InstructionReportErrorCode>,
6188        #[case] bet_taken_is_success: bool,
6189        #[case] expected: Result<(), CommandFailure>,
6190    ) {
6191        assert_eq!(
6192            classify_instruction_report(status, error_code, bet_taken_is_success, || {
6193                "instruction reason".to_string()
6194            }),
6195            expected,
6196        );
6197    }
6198
6199    #[rstest]
6200    #[case(
6201        Some((InstructionReportStatus::Success, None)),
6202        Some((InstructionReportStatus::Success, None)),
6203        Ok(())
6204    )]
6205    #[case(
6206        None,
6207        Some((InstructionReportStatus::Success, None)),
6208        Err(CommandFailure::Ambiguous("replace reason".to_string()))
6209    )]
6210    #[case(
6211        Some((InstructionReportStatus::Success, None)),
6212        None,
6213        Err(CommandFailure::Ambiguous("replace reason".to_string()))
6214    )]
6215    #[case(
6216        Some((InstructionReportStatus::Success, None)),
6217        Some((InstructionReportStatus::Timeout, None)),
6218        Err(CommandFailure::Ambiguous("replace reason".to_string()))
6219    )]
6220    #[case(
6221        Some((
6222            InstructionReportStatus::Failure,
6223            Some(InstructionReportErrorCode::ErrorInOrder),
6224        )),
6225        Some((InstructionReportStatus::Success, None)),
6226        Err(CommandFailure::VenueRejected("replace reason".to_string()))
6227    )]
6228    fn test_classify_replace_instruction(
6229        #[case] cancel: Option<(InstructionReportStatus, Option<InstructionReportErrorCode>)>,
6230        #[case] place: Option<(InstructionReportStatus, Option<InstructionReportErrorCode>)>,
6231        #[case] expected: Result<(), CommandFailure>,
6232    ) {
6233        let report = ReplaceInstructionReport {
6234            status: InstructionReportStatus::Success,
6235            error_code: None,
6236            error_message: None,
6237            cancel_instruction_report: cancel.map(|(status, error_code)| CancelInstructionReport {
6238                status,
6239                error_code,
6240                error_message: None,
6241                instruction: None,
6242                size_cancelled: None,
6243                cancelled_date: None,
6244            }),
6245            place_instruction_report: place.map(|(status, error_code)| PlaceInstructionReport {
6246                status,
6247                error_code,
6248                error_message: None,
6249                order_status: None,
6250                instruction: None,
6251                bet_id: None,
6252                placed_date: None,
6253                average_price_matched: None,
6254                size_matched: None,
6255            }),
6256        };
6257
6258        assert_eq!(
6259            classify_replace_instruction(&report, "replace reason".to_string()),
6260            expected,
6261        );
6262    }
6263
6264    #[rstest]
6265    #[case(
6266        Some(InstructionReportErrorCode::CancelledNotPlaced),
6267        Some(InstructionReportStatus::Success),
6268        Some(InstructionReportStatus::Failure),
6269        true
6270    )]
6271    #[case(
6272        Some(InstructionReportErrorCode::ErrorInOrder),
6273        Some(InstructionReportStatus::Success),
6274        Some(InstructionReportStatus::Failure),
6275        false
6276    )]
6277    #[case(
6278        Some(InstructionReportErrorCode::CancelledNotPlaced),
6279        Some(InstructionReportStatus::Failure),
6280        Some(InstructionReportStatus::Failure),
6281        false
6282    )]
6283    #[case(
6284        Some(InstructionReportErrorCode::CancelledNotPlaced),
6285        Some(InstructionReportStatus::Success),
6286        Some(InstructionReportStatus::Success),
6287        false
6288    )]
6289    #[case(
6290        Some(InstructionReportErrorCode::CancelledNotPlaced),
6291        None,
6292        Some(InstructionReportStatus::Failure),
6293        false
6294    )]
6295    #[case(
6296        Some(InstructionReportErrorCode::CancelledNotPlaced),
6297        Some(InstructionReportStatus::Success),
6298        None,
6299        false
6300    )]
6301    fn test_replace_cancelled_without_replacement(
6302        #[case] error_code: Option<InstructionReportErrorCode>,
6303        #[case] cancel_status: Option<InstructionReportStatus>,
6304        #[case] place_status: Option<InstructionReportStatus>,
6305        #[case] expected: bool,
6306    ) {
6307        let report = ReplaceInstructionReport {
6308            status: InstructionReportStatus::Failure,
6309            error_code,
6310            error_message: None,
6311            cancel_instruction_report: cancel_status.map(|status| CancelInstructionReport {
6312                status,
6313                error_code: None,
6314                error_message: None,
6315                instruction: None,
6316                size_cancelled: None,
6317                cancelled_date: None,
6318            }),
6319            place_instruction_report: place_status.map(|status| PlaceInstructionReport {
6320                status,
6321                error_code: Some(InstructionReportErrorCode::InvalidOdds),
6322                error_message: None,
6323                order_status: None,
6324                instruction: None,
6325                bet_id: None,
6326                placed_date: None,
6327                average_price_matched: None,
6328                size_matched: None,
6329            }),
6330        };
6331
6332        assert_eq!(
6333            replace_cancelled_without_replacement(Some(&report)),
6334            expected
6335        );
6336        assert!(!replace_cancelled_without_replacement(None));
6337    }
6338
6339    #[rstest]
6340    #[case(
6341        BetfairHttpError::MissingCredentials,
6342        CommandFailure::NotSent("Missing API credentials".to_string())
6343    )]
6344    #[case(
6345        BetfairHttpError::Timeout("request timed out".to_string()),
6346        CommandFailure::Ambiguous("Timeout: request timed out".to_string())
6347    )]
6348    #[case(
6349        BetfairHttpError::OrderRequestAmbiguous("earlier attempt".to_string()),
6350        CommandFailure::Ambiguous("Ambiguous order request: earlier attempt".to_string())
6351    )]
6352    #[case(
6353        BetfairHttpError::JsonError("request encoding".to_string()),
6354        CommandFailure::NotSent("JSON error: request encoding".to_string())
6355    )]
6356    #[case(
6357        BetfairHttpError::ResponseError("truncated response".to_string()),
6358        CommandFailure::Ambiguous("Response error: truncated response".to_string())
6359    )]
6360    #[case(
6361        BetfairHttpError::UnexpectedStatus {
6362            status: 500,
6363            body: "server error".to_string(),
6364        },
6365        CommandFailure::Ambiguous("Unexpected status 500: server error".to_string())
6366    )]
6367    #[case(
6368        BetfairHttpError::UnexpectedStatus {
6369            status: 429,
6370            body: "too many requests".to_string(),
6371        },
6372        CommandFailure::VenueRejected(
6373            "Unexpected status 429: too many requests".to_string()
6374        )
6375    )]
6376    #[case(
6377        BetfairHttpError::BetfairError {
6378            code: -32099,
6379            message: "ANGX-0001".to_string(),
6380            api_error_code: Some("TOO_MUCH_DATA".to_string()),
6381            api_error_details: Some(
6382                "MaxResults must be less than or equal to 1000".to_string()
6383            ),
6384        },
6385        CommandFailure::VenueRejected(
6386            "Betfair error -32099: ANGX-0001 (TOO_MUCH_DATA: MaxResults must be less than or equal to 1000)".to_string()
6387        )
6388    )]
6389    fn test_classify_http_error(#[case] error: BetfairHttpError, #[case] expected: CommandFailure) {
6390        assert_eq!(classify_http_error(&error), expected);
6391    }
6392
6393    #[rstest]
6394    #[case(
6395        Some(InstructionReportErrorCode::ErrorInOrder),
6396        None,
6397        "unknown",
6398        "ErrorInOrder"
6399    )]
6400    #[case(None, Some("report error".to_string()), "unknown", "report error")]
6401    #[case(None, None, "unknown error", "unknown error")]
6402    fn test_format_betfair_reason(
6403        #[case] error_code: Option<InstructionReportErrorCode>,
6404        #[case] fallback: Option<String>,
6405        #[case] unknown: &str,
6406        #[case] expected: &str,
6407    ) {
6408        assert_eq!(
6409            format_betfair_reason(error_code, fallback, unknown),
6410            expected
6411        );
6412    }
6413
6414    #[rstest]
6415    fn test_ocm_state_register_and_resolve() {
6416        let mut state = OcmState::default();
6417        let client_oid = ClientOrderId::from("O-20240101-001");
6418
6419        state.register_order_ref(client_oid).unwrap();
6420
6421        let rfo = make_customer_order_ref(client_oid.as_str());
6422        let resolved = state.resolve_client_order_id(Some(&rfo));
6423        assert_eq!(resolved, Some(client_oid));
6424    }
6425
6426    #[rstest]
6427    fn test_ocm_state_resolve_none_for_unknown_rfo() {
6428        let state = OcmState::default();
6429        assert!(state.resolve_client_order_id(Some("unknown")).is_none());
6430        assert!(state.resolve_client_order_id(None).is_none());
6431    }
6432
6433    #[rstest]
6434    fn test_ocm_state_register_with_legacy() {
6435        let mut state = OcmState::default();
6436        let id = "O-20240101-550e8400-e29b-41d4-a716-446655440000";
6437        let client_oid = ClientOrderId::from(id);
6438
6439        state.restore_order(
6440            client_oid,
6441            StrategyId::from("S-001"),
6442            VenueOrderId::from("bet-1"),
6443        );
6444
6445        let rfo_current = make_customer_order_ref(id);
6446        let rfo_legacy = make_customer_order_ref_legacy(id);
6447        assert_ne!(rfo_current, rfo_legacy);
6448
6449        assert_eq!(
6450            state.resolve_client_order_id(Some(&rfo_current)),
6451            Some(client_oid)
6452        );
6453        assert_eq!(
6454            state.resolve_client_order_id(Some(&rfo_legacy)),
6455            Some(client_oid)
6456        );
6457    }
6458
6459    #[rstest]
6460    fn test_ocm_state_remove_order_correlation() {
6461        let mut state = OcmState::default();
6462        let id = "O-20240101-550e8400-e29b-41d4-a716-446655440000";
6463        let client_oid = ClientOrderId::from(id);
6464
6465        state.restore_order(
6466            client_oid,
6467            StrategyId::from("S-001"),
6468            VenueOrderId::from("bet-1"),
6469        );
6470        state.remove_order_correlation(&client_oid);
6471
6472        let rfo_current = make_customer_order_ref(id);
6473        let rfo_legacy = make_customer_order_ref_legacy(id);
6474        assert!(state.resolve_client_order_id(Some(&rfo_current)).is_none());
6475        assert!(state.resolve_client_order_id(Some(&rfo_legacy)).is_none());
6476    }
6477
6478    #[rstest]
6479    fn test_http_accept_emits_when_unclaimed() {
6480        let state = Arc::new(Mutex::new(OcmState::default()));
6481        let client_oid = ClientOrderId::from("O-001");
6482        state
6483            .lock()
6484            .register_submission(client_oid, StrategyId::from("S-001"))
6485            .unwrap();
6486
6487        let mut emitted = false;
6488        emit_http_accept_if_claimed(&state, &client_oid, VenueOrderId::from("bet-1"), || {
6489            emitted = true;
6490        });
6491        assert!(emitted, "first HTTP accept must emit");
6492
6493        // A second claim for the same order is suppressed (already accepted).
6494        let mut emitted_again = false;
6495        emit_http_accept_if_claimed(&state, &client_oid, VenueOrderId::from("bet-1"), || {
6496            emitted_again = true;
6497        });
6498        assert!(!emitted_again, "already-accepted order must not re-emit");
6499    }
6500
6501    #[rstest]
6502    fn test_http_accept_suppressed_after_stream_report() {
6503        let client_oid = ClientOrderId::from("O-001");
6504        let mut inner = OcmState::default();
6505        inner
6506            .register_submission(client_oid, StrategyId::from("S-001"))
6507            .unwrap();
6508        inner.mark_accepted(client_oid);
6509        let state = Arc::new(Mutex::new(inner));
6510
6511        let mut emitted = false;
6512        emit_http_accept_if_claimed(&state, &client_oid, VenueOrderId::from("bet-1"), || {
6513            emitted = true;
6514        });
6515        assert!(!emitted, "OCM-reported order must suppress the HTTP accept");
6516    }
6517
6518    #[rstest]
6519    fn test_http_reject_emits_and_removes_correlation_without_stream_report() {
6520        let state = Arc::new(Mutex::new(OcmState::default()));
6521        let client_oid = ClientOrderId::from("O-001");
6522        state
6523            .lock()
6524            .register_submission(client_oid, StrategyId::from("S-001"))
6525            .unwrap();
6526        let mut emitted = false;
6527
6528        emit_http_reject_if_unreported(
6529            &state,
6530            &client_oid,
6531            "BetLapsedPriceImprovementTooLarge",
6532            || emitted = true,
6533        );
6534
6535        assert!(emitted);
6536        let rfo = make_customer_order_ref(client_oid.as_str());
6537        assert_eq!(state.lock().resolve_client_order_id(Some(&rfo)), None);
6538    }
6539
6540    #[rstest]
6541    fn test_http_reject_suppressed_after_stream_report() {
6542        // OCM-first race: the stream has already moved the order through
6543        // a terminal state (e.g. lapsed). A late HTTP rejection would
6544        // hit InvalidStateTrigger and pollute the own book audit log.
6545        let client_oid = ClientOrderId::from("O-001");
6546        let mut inner = OcmState::default();
6547        inner
6548            .register_submission(client_oid, StrategyId::from("S-001"))
6549            .unwrap();
6550        inner.mark_accepted(client_oid);
6551        let state = Arc::new(Mutex::new(inner));
6552        let mut emitted = false;
6553
6554        emit_http_reject_if_unreported(
6555            &state,
6556            &client_oid,
6557            "BetLapsedPriceImprovementTooLarge",
6558            || emitted = true,
6559        );
6560
6561        assert!(!emitted);
6562        let rfo = make_customer_order_ref(client_oid.as_str());
6563        assert_eq!(
6564            state.lock().resolve_client_order_id(Some(&rfo)),
6565            Some(client_oid),
6566        );
6567    }
6568
6569    fn cancel_unmatched_order(
6570        bet_id: &str,
6571        rfo: Option<String>,
6572    ) -> crate::stream::messages::UnmatchedOrder {
6573        crate::stream::messages::UnmatchedOrder {
6574            id: bet_id.to_string(),
6575            p: Decimal::new(30, 1),
6576            s: Decimal::new(20, 0),
6577            side: crate::common::enums::StreamingSide::Back,
6578            status: crate::common::enums::StreamingOrderStatus::ExecutionComplete,
6579            pt: Some(crate::common::enums::StreamingPersistenceType::Lapse),
6580            ot: crate::common::enums::StreamingOrderType::Limit,
6581            pd: 1617863365000,
6582            bsp: None,
6583            rfo,
6584            rfs: None,
6585            rc: None,
6586            rac: None,
6587            md: None,
6588            cd: None,
6589            ld: None,
6590            avp: None,
6591            sm: None,
6592            sr: None,
6593            sl: None,
6594            sc: Some(Decimal::new(20, 0)),
6595            sv: None,
6596            lsrc: Some(crate::common::enums::LapseStatusReasonCode::SpInPlay),
6597        }
6598    }
6599
6600    fn resting_sp_unmatched_order(
6601        bet_id: &str,
6602        rfo: Option<String>,
6603    ) -> crate::stream::messages::UnmatchedOrder {
6604        crate::stream::messages::UnmatchedOrder {
6605            id: bet_id.to_string(),
6606            p: Decimal::new(10000, 1),
6607            s: Decimal::ZERO,
6608            side: crate::common::enums::StreamingSide::Back,
6609            status: crate::common::enums::StreamingOrderStatus::ExecutionComplete,
6610            pt: Some(crate::common::enums::StreamingPersistenceType::MarketOnClose),
6611            ot: crate::common::enums::StreamingOrderType::MarketOnClose,
6612            pd: 1789423573000,
6613            bsp: Some(Decimal::new(2, 0)),
6614            rfo,
6615            rfs: None,
6616            rc: None,
6617            rac: None,
6618            md: None,
6619            cd: None,
6620            ld: None,
6621            avp: None,
6622            sm: Some(Decimal::ZERO),
6623            sr: Some(Decimal::ZERO),
6624            sl: Some(Decimal::ZERO),
6625            sc: Some(Decimal::ZERO),
6626            sv: Some(Decimal::ZERO),
6627            lsrc: None,
6628        }
6629    }
6630
6631    #[rstest]
6632    fn test_stream_active_quantity_includes_voided() {
6633        let order = crate::stream::messages::UnmatchedOrder {
6634            sm: Some(Decimal::from(3)),
6635            sr: Some(Decimal::from(4)),
6636            sv: Some(Decimal::from(2)),
6637            ..resting_sp_unmatched_order("bet-1", None)
6638        };
6639
6640        assert_eq!(
6641            stream_active_quantity(&order),
6642            Some(Quantity::from(9)),
6643            "sm(3) + sr(4) + sv(2) must all contribute to the gross active quantity"
6644        );
6645    }
6646
6647    #[rstest]
6648    fn test_current_order_active_quantity_includes_voided() {
6649        let mut order = make_summary(
6650            "bet-1",
6651            "1.100",
6652            12345,
6653            Decimal::ZERO,
6654            BetfairOrderStatus::Executable,
6655            "2026-08-25T00:00:00Z",
6656        );
6657        order.size_matched = Some(Decimal::from(3));
6658        order.size_remaining = Some(Decimal::from(4));
6659        order.size_voided = Some(Decimal::from(2));
6660
6661        assert_eq!(
6662            current_order_active_quantity(&order).unwrap(),
6663            Quantity::from(9),
6664            "size_matched(3) + size_remaining(4) + size_voided(2) must all contribute, matching \
6665             the HTTP status-report path's gross lifecycle quantity"
6666        );
6667    }
6668
6669    #[rstest]
6670    fn test_http_stream_and_reconciliation_agree_on_gross_active_quantity() {
6671        let matched = Decimal::from(3);
6672        let remaining = Decimal::from(4);
6673        let voided = Decimal::from(2);
6674        let expected = Quantity::from(9);
6675
6676        let stream_order = crate::stream::messages::UnmatchedOrder {
6677            sm: Some(matched),
6678            sr: Some(remaining),
6679            sv: Some(voided),
6680            ..resting_sp_unmatched_order("bet-1", None)
6681        };
6682        assert_eq!(stream_active_quantity(&stream_order), Some(expected));
6683
6684        let mut reconciliation_order = make_summary(
6685            "bet-1",
6686            "1.100",
6687            12345,
6688            Decimal::ZERO,
6689            BetfairOrderStatus::Executable,
6690            "2026-08-25T00:00:00Z",
6691        );
6692        reconciliation_order.size_matched = Some(matched);
6693        reconciliation_order.size_remaining = Some(remaining);
6694        reconciliation_order.size_voided = Some(voided);
6695        assert_eq!(
6696            current_order_active_quantity(&reconciliation_order).unwrap(),
6697            expected
6698        );
6699
6700        let mut http_order = reconciliation_order;
6701        http_order.price_size.size = Decimal::ZERO;
6702        http_order.size_cancelled = Some(Decimal::ZERO);
6703        http_order.size_lapsed = Some(Decimal::ZERO);
6704        let report = parse_current_order_report(
6705            &http_order,
6706            AccountId::from("BETFAIR-001"),
6707            UnixNanos::default(),
6708        )
6709        .unwrap();
6710        assert_eq!(report.quantity, expected);
6711    }
6712
6713    #[rstest]
6714    #[case::reduction_confirms_then_void_arrives(false)]
6715    #[case::void_present_before_reduction_confirms(true)]
6716    fn test_same_bet_reduction_and_void_ordering_agree(#[case] void_first: bool) {
6717        let client_order_id = ClientOrderId::from("O-1");
6718        let strategy_id = StrategyId::from("S-001");
6719        let bet_id = "bet-1";
6720        let mut state = OcmState::default();
6721        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(bet_id));
6722        state.register_pending_reduction(
6723            client_order_id,
6724            bet_id.to_string(),
6725            Quantity::from(10),
6726            Quantity::from(6),
6727        );
6728
6729        let update = |sm: i64, sr: i64, sv: i64| crate::stream::messages::UnmatchedOrder {
6730            sm: Some(Decimal::from(sm)),
6731            sr: Some(Decimal::from(sr)),
6732            sv: Some(Decimal::from(sv)),
6733            ..resting_sp_unmatched_order(bet_id, None)
6734        };
6735
6736        if void_first {
6737            // The void lands before the reduction takes visible effect on the wire: gross
6738            // still equals the original size, so nothing confirms yet.
6739            let result = BetfairExecutionClient::resolve_pending_reduction_from_stream(
6740                &mut state,
6741                Some((client_order_id, strategy_id)),
6742                &update(2, 7, 1),
6743            );
6744            assert_eq!(result, None);
6745
6746            // The reduction now takes effect, with the earlier void still present
6747            let result = BetfairExecutionClient::resolve_pending_reduction_from_stream(
6748                &mut state,
6749                Some((client_order_id, strategy_id)),
6750                &update(2, 3, 1),
6751            );
6752            assert_eq!(
6753                result,
6754                Some((client_order_id, strategy_id, Quantity::from(6)))
6755            );
6756        } else {
6757            // The reduction confirms first, with no void yet
6758            let result = BetfairExecutionClient::resolve_pending_reduction_from_stream(
6759                &mut state,
6760                Some((client_order_id, strategy_id)),
6761                &update(2, 4, 0),
6762            );
6763            assert_eq!(
6764                result,
6765                Some((client_order_id, strategy_id, Quantity::from(6)))
6766            );
6767
6768            // A later void on the same, already-confirmed bet reshuffles sr -> sv without
6769            // changing the gross total; it must not re-trigger or corrupt the confirmation.
6770            let result = BetfairExecutionClient::resolve_pending_reduction_from_stream(
6771                &mut state,
6772                Some((client_order_id, strategy_id)),
6773                &update(2, 3, 1),
6774            );
6775            assert_eq!(result, None);
6776        }
6777
6778        assert_eq!(state.reduced_quantity(bet_id), Some(Quantity::from(6)));
6779    }
6780
6781    fn emitter_with_receiver(
6782        account_id: AccountId,
6783    ) -> (
6784        ExecutionEventEmitter,
6785        tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
6786    ) {
6787        let clock = get_atomic_clock_realtime();
6788        let mut emitter = ExecutionEventEmitter::new(
6789            clock,
6790            TraderId::from("TESTER-001"),
6791            account_id,
6792            AccountType::Betting,
6793            None,
6794        );
6795        let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
6796        emitter.set_sender(tx);
6797        (emitter, rx)
6798    }
6799
6800    #[expect(
6801        clippy::type_complexity,
6802        reason = "The tuple exposes each test channel and the replay buffer"
6803    )]
6804    fn ocm_handler_at(
6805        ts_init: UnixNanos,
6806        pending_resync: bool,
6807    ) -> (
6808        StreamMessageHandler,
6809        tokio::sync::mpsc::UnboundedReceiver<DataEvent>,
6810        tokio::sync::mpsc::UnboundedReceiver<ExecutionEvent>,
6811        Arc<Mutex<Vec<ReceivedOcm>>>,
6812    ) {
6813        let account_id = AccountId::from("BETFAIR-001");
6814        let (emitter, execution_rx) = emitter_with_receiver(account_id);
6815        let (data_tx, data_rx) = tokio::sync::mpsc::unbounded_channel();
6816        let (reconnect_tx, _reconnect_rx) = tokio::sync::mpsc::unbounded_channel();
6817        let (account_refresh_tx, _account_refresh_rx) = tokio::sync::mpsc::unbounded_channel();
6818        let replay_buffer = Arc::new(Mutex::new(Vec::new()));
6819        let clock = Box::leak(Box::new(AtomicTime::new(false, ts_init)));
6820
6821        let handler = BetfairExecutionClient::create_ocm_handler(
6822            emitter,
6823            account_id,
6824            Currency::GBP(),
6825            Arc::new(Mutex::new(OcmState::default())),
6826            data_tx.into(),
6827            None,
6828            false,
6829            reconnect_tx,
6830            Arc::new(AtomicU64::new(0)),
6831            Arc::new(AtomicBool::new(pending_resync)),
6832            Arc::new(ReconciliationGate::default()),
6833            Arc::clone(&replay_buffer),
6834            account_refresh_tx,
6835            clock,
6836        );
6837
6838        (handler, data_rx, execution_rx, replay_buffer)
6839    }
6840
6841    #[rstest]
6842    fn test_ocm_handler_sets_init_from_clock() {
6843        let ts_init = UnixNanos::from(1_800_000_000_000_000_004);
6844
6845        let (handler, mut data_rx, _execution_rx, replay_buffer) = ocm_handler_at(ts_init, false);
6846        let data = load_test_json("stream/ocm_VOIDED.json");
6847
6848        handler(stream_decode(data.as_bytes()).unwrap());
6849
6850        let custom = std::iter::from_fn(|| data_rx.try_recv().ok())
6851            .find_map(|event| match event {
6852                DataEvent::Data(Data::Custom(custom))
6853                    if custom.data.as_any().is::<BetfairOrderVoided>() =>
6854                {
6855                    Some(custom.data)
6856                }
6857                _ => None,
6858            })
6859            .expect("expected BetfairOrderVoided custom data");
6860        let voided = custom
6861            .as_any()
6862            .downcast_ref::<BetfairOrderVoided>()
6863            .unwrap();
6864
6865        assert_eq!(voided.ts_event, UnixNanos::from(1_617_863_371_576_000_000));
6866        assert_eq!(voided.ts_init, ts_init);
6867        assert!(replay_buffer.lock().is_empty());
6868    }
6869
6870    #[rstest]
6871    fn test_ocm_handler_preserves_buffered_init() {
6872        let ts_init = UnixNanos::from(1_800_000_000_000_000_005);
6873
6874        let (handler, mut data_rx, mut execution_rx, replay_buffer) = ocm_handler_at(ts_init, true);
6875        let data = load_test_json("stream/ocm_VOIDED.json");
6876
6877        handler(stream_decode(data.as_bytes()).unwrap());
6878
6879        let received = replay_buffer.lock().pop().unwrap();
6880
6881        assert!(data_rx.try_recv().is_err());
6882        assert!(execution_rx.try_recv().is_err());
6883
6884        let account_id = AccountId::from("BETFAIR-001");
6885        let (emitter, _execution_rx) = emitter_with_receiver(account_id);
6886        let (data_tx, mut data_rx) = tokio::sync::mpsc::unbounded_channel();
6887        BetfairExecutionClient::process_ocm(
6888            &received,
6889            account_id,
6890            Currency::GBP(),
6891            &emitter,
6892            &Arc::new(Mutex::new(OcmState::default())),
6893            &data_tx.into(),
6894            None,
6895            false,
6896            None,
6897        );
6898
6899        let custom = std::iter::from_fn(|| data_rx.try_recv().ok())
6900            .find_map(|event| match event {
6901                DataEvent::Data(Data::Custom(custom))
6902                    if custom.data.as_any().is::<BetfairOrderVoided>() =>
6903                {
6904                    Some(custom.data)
6905                }
6906                _ => None,
6907            })
6908            .expect("expected buffered BetfairOrderVoided custom data");
6909        let voided = custom
6910            .as_any()
6911            .downcast_ref::<BetfairOrderVoided>()
6912            .unwrap();
6913
6914        assert_eq!(voided.ts_event, UnixNanos::from(1_617_863_371_576_000_000));
6915        assert_eq!(voided.ts_init, ts_init);
6916        assert!(replay_buffer.lock().is_empty());
6917    }
6918
6919    #[rstest]
6920    fn test_ocm_handler_buffers_each_segment_once() {
6921        let ts_init = UnixNanos::from(1_800_000_000_000_000_006);
6922        let (handler, mut data_rx, mut execution_rx, replay_buffer) = ocm_handler_at(ts_init, true);
6923        let data = load_test_json("stream/ocm_SEGMENTS.jsonl");
6924
6925        for line in data.lines() {
6926            handler(stream_decode(line.as_bytes()).unwrap());
6927        }
6928
6929        let received = replay_buffer.lock();
6930        assert_eq!(received.len(), 3);
6931        assert_eq!(
6932            received[0].message.segment_type,
6933            Some(SegmentType::SegStart)
6934        );
6935        assert_eq!(received[1].message.segment_type, Some(SegmentType::Seg));
6936        assert_eq!(received[2].message.segment_type, Some(SegmentType::SegEnd));
6937        assert!(received.iter().all(|message| message.ts_init == ts_init));
6938        assert_eq!(
6939            received
6940                .iter()
6941                .map(|message| message.message.oc.as_ref().unwrap()[0].id.as_str())
6942                .collect::<Vec<_>>(),
6943            vec!["1.100001", "1.100002", "1.100003"],
6944        );
6945        assert!(data_rx.try_recv().is_err());
6946        assert!(execution_rx.try_recv().is_err());
6947    }
6948
6949    #[rstest]
6950    fn test_ocm_handler_stress_buffers_segments_once_in_order() {
6951        const SEQUENCE_COUNT: usize = 1_024;
6952        const MAX_MIDDLE_SEGMENTS: usize = 15;
6953
6954        let ts_init = UnixNanos::from(1_800_000_000_000_000_007);
6955        let (handler, mut data_rx, mut execution_rx, replay_buffer) = ocm_handler_at(ts_init, true);
6956        let data = load_test_json("stream/ocm_SEGMENTS.jsonl");
6957        let segments = data.lines().collect::<Vec<_>>();
6958        let mut expected = Vec::new();
6959
6960        for sequence in 0..SEQUENCE_COUNT {
6961            handler(stream_decode(segments[0].as_bytes()).unwrap());
6962            expected.push((SegmentType::SegStart, "1.100001"));
6963
6964            for _ in 0..sequence % (MAX_MIDDLE_SEGMENTS + 1) {
6965                handler(stream_decode(segments[1].as_bytes()).unwrap());
6966                expected.push((SegmentType::Seg, "1.100002"));
6967            }
6968
6969            handler(stream_decode(segments[2].as_bytes()).unwrap());
6970            expected.push((SegmentType::SegEnd, "1.100003"));
6971        }
6972
6973        let received = replay_buffer.lock();
6974        assert_eq!(received.len(), expected.len());
6975        for (message, (segment_type, market_id)) in received.iter().zip(expected) {
6976            assert_eq!(message.message.segment_type, Some(segment_type));
6977            assert_eq!(message.ts_init, ts_init);
6978            assert_eq!(
6979                message.message.oc.as_ref().unwrap()[0].id.as_str(),
6980                market_id,
6981            );
6982        }
6983        assert!(data_rx.try_recv().is_err());
6984        assert!(execution_rx.try_recv().is_err());
6985    }
6986
6987    #[rstest]
6988    fn test_tracked_cancel_emits_direct_order_canceled() {
6989        // A tracked cancel must emit a direct OrderCanceled, not a deferrable report.
6990        let account_id = AccountId::from("BETFAIR-001");
6991        let client_order_id = ClientOrderId::from("O-CANCEL-001");
6992        let strategy_id = StrategyId::from("S-QUOTER");
6993
6994        let mut inner = OcmState::default();
6995        inner
6996            .register_submission(client_order_id, strategy_id)
6997            .unwrap();
6998        inner.mark_accepted(client_order_id); // accepted before cancel (no synthesized accept)
6999        let ocm_state = Arc::new(Mutex::new(inner));
7000
7001        let (emitter, mut rx) = emitter_with_receiver(account_id);
7002        let rfo = make_customer_order_ref(client_order_id.as_str());
7003        let uo = cancel_unmatched_order("bet_cancel", Some(rfo));
7004
7005        let processed = BetfairExecutionClient::process_unmatched_order(
7006            &uo,
7007            InstrumentId::from("1.234567-12345-0.0.BETFAIR"),
7008            account_id,
7009            Currency::from("GBP"),
7010            &emitter,
7011            &ocm_state,
7012            UnixNanos::default(),
7013            UnixNanos::default(),
7014        );
7015
7016        assert!(processed);
7017
7018        match rx.try_recv().expect("expected an execution event") {
7019            ExecutionEvent::Order(OrderEventAny::Canceled(canceled)) => {
7020                assert_eq!(canceled.client_order_id, client_order_id);
7021                assert_eq!(canceled.strategy_id, strategy_id);
7022                assert_eq!(
7023                    canceled.venue_order_id,
7024                    Some(VenueOrderId::from("bet_cancel"))
7025                );
7026            }
7027            other => panic!("expected a direct OrderCanceled event, was {other:?}"),
7028        }
7029
7030        assert!(
7031            rx.try_recv().is_err(),
7032            "tracked cancel must not also emit a status report",
7033        );
7034    }
7035
7036    #[rstest]
7037    fn test_untracked_cancel_emits_status_report() {
7038        // An order with no registered identity is external: its cancel takes the report path.
7039        let account_id = AccountId::from("BETFAIR-001");
7040        let ocm_state = Arc::new(Mutex::new(OcmState::default()));
7041
7042        let (emitter, mut rx) = emitter_with_receiver(account_id);
7043        let uo = cancel_unmatched_order("bet_external", Some("EXTERNAL-REF".to_string()));
7044
7045        let processed = BetfairExecutionClient::process_unmatched_order(
7046            &uo,
7047            InstrumentId::from("1.234567-12345-0.0.BETFAIR"),
7048            account_id,
7049            Currency::from("GBP"),
7050            &emitter,
7051            &ocm_state,
7052            UnixNanos::default(),
7053            UnixNanos::default(),
7054        );
7055
7056        assert!(processed);
7057
7058        match rx.try_recv().expect("expected an execution event") {
7059            ExecutionEvent::Report(ExecutionReport::Order(report)) => {
7060                assert_eq!(report.order_status, OrderStatus::Canceled);
7061                assert_eq!(report.venue_order_id, VenueOrderId::from("bet_external"));
7062            }
7063            other => panic!("expected an OrderStatusReport, was {other:?}"),
7064        }
7065    }
7066
7067    #[rstest]
7068    fn test_tracked_resting_sp_bet_stays_open() {
7069        // A resting SP bet is execution-complete with zero sizes but cannot be
7070        // cancelled: it must not emit a terminal event or be marked terminal.
7071        let account_id = AccountId::from("BETFAIR-001");
7072        let client_order_id = ClientOrderId::from("O-SP-001");
7073        let strategy_id = StrategyId::from("S-QUOTER");
7074
7075        let mut inner = OcmState::default();
7076        inner
7077            .register_submission(client_order_id, strategy_id)
7078            .unwrap();
7079        inner.mark_accepted(client_order_id);
7080        let ocm_state = Arc::new(Mutex::new(inner));
7081
7082        let (emitter, mut rx) = emitter_with_receiver(account_id);
7083        let rfo = make_customer_order_ref(client_order_id.as_str());
7084        let uo = resting_sp_unmatched_order("bet_sp_resting", Some(rfo));
7085
7086        let processed = BetfairExecutionClient::process_unmatched_order(
7087            &uo,
7088            InstrumentId::from("1.234567-12345-0.0.BETFAIR"),
7089            account_id,
7090            Currency::from("GBP"),
7091            &emitter,
7092            &ocm_state,
7093            UnixNanos::default(),
7094            UnixNanos::default(),
7095        );
7096
7097        assert!(processed);
7098        assert!(
7099            rx.try_recv().is_err(),
7100            "resting SP bet must not emit a terminal event",
7101        );
7102
7103        // The bet was not marked terminal, so a repeat update still processes
7104        let processed_again = BetfairExecutionClient::process_unmatched_order(
7105            &uo,
7106            InstrumentId::from("1.234567-12345-0.0.BETFAIR"),
7107            account_id,
7108            Currency::from("GBP"),
7109            &emitter,
7110            &ocm_state,
7111            UnixNanos::default(),
7112            UnixNanos::default(),
7113        );
7114
7115        assert!(processed_again);
7116        assert!(rx.try_recv().is_err());
7117    }
7118
7119    #[rstest]
7120    #[case::current(
7121        "FIRST-12345678901234567890123456789012",
7122        "SECOND-12345678901234567890123456789012",
7123        "12345678901234567890123456789012"
7124    )]
7125    #[case::legacy(
7126        "12345678901234567890123456789012-FIRST",
7127        "12345678901234567890123456789012-SECOND",
7128        "12345678901234567890123456789012"
7129    )]
7130    fn test_ambiguous_customer_order_ref_does_not_route_status_or_fill(
7131        #[case] first_id: &str,
7132        #[case] second_id: &str,
7133        #[case] customer_order_ref: &str,
7134    ) {
7135        let account_id = AccountId::from("BETFAIR-001");
7136        let first = ClientOrderId::from(first_id);
7137        let second = ClientOrderId::from(second_id);
7138        let mut state = OcmState::default();
7139        state.restore_order(
7140            first,
7141            StrategyId::from("S-FIRST"),
7142            VenueOrderId::from("bet-first"),
7143        );
7144        state.restore_order(
7145            second,
7146            StrategyId::from("S-SECOND"),
7147            VenueOrderId::from("bet-second"),
7148        );
7149        let ocm_state = Arc::new(Mutex::new(state));
7150        let (emitter, mut rx) = emitter_with_receiver(account_id);
7151        let order = fill_unmatched_order(
7152            "bet-ambiguous",
7153            Some(customer_order_ref.to_string()),
7154            Decimal::new(10, 0),
7155        );
7156
7157        let processed = BetfairExecutionClient::process_unmatched_order(
7158            &order,
7159            InstrumentId::from("1.234567-12345-0.0.BETFAIR"),
7160            account_id,
7161            Currency::from("GBP"),
7162            &emitter,
7163            &ocm_state,
7164            UnixNanos::default(),
7165            UnixNanos::default(),
7166        );
7167
7168        assert!(processed);
7169
7170        match rx.try_recv().expect("expected a fill report") {
7171            ExecutionEvent::Report(ExecutionReport::Fill(fill)) => {
7172                assert_eq!(fill.client_order_id, None);
7173                assert_eq!(fill.venue_order_id, VenueOrderId::from("bet-ambiguous"));
7174            }
7175            other => panic!("ambiguous reference must emit an unowned fill report: {other:?}"),
7176        }
7177
7178        match rx.try_recv().expect("expected a status report") {
7179            ExecutionEvent::Report(ExecutionReport::Order(report)) => {
7180                assert_eq!(report.client_order_id, None);
7181                assert_eq!(report.venue_order_id, VenueOrderId::from("bet-ambiguous"));
7182            }
7183            other => panic!("ambiguous reference must emit an unowned status report: {other:?}"),
7184        }
7185        assert!(rx.try_recv().is_err());
7186    }
7187
7188    #[rstest]
7189    fn test_ambiguous_customer_order_ref_does_not_evict_known_pending_identity() {
7190        let account_id = AccountId::from("BETFAIR-001");
7191        let suffix = "12345678901234567890123456789012";
7192        let first = ClientOrderId::from(format!("FIRST-{suffix}"));
7193        let second = ClientOrderId::from(format!("SECOND-{suffix}"));
7194        let bet_id = "bet-first";
7195        let mut state = OcmState::default();
7196        state.restore_order(
7197            first,
7198            StrategyId::from("S-FIRST"),
7199            VenueOrderId::from(bet_id),
7200        );
7201        state.restore_order(
7202            second,
7203            StrategyId::from("S-SECOND"),
7204            VenueOrderId::from("bet-second"),
7205        );
7206        state.register_pending_replace(first, bet_id.to_string(), Some(Quantity::from(20)));
7207        state.mark_pending_replace_ambiguous(first, bet_id);
7208        state.fill_tracker.advance_cumulative_fill(
7209            bet_id,
7210            Decimal::from(2),
7211            Some(Decimal::from(3)),
7212            Decimal::from(3),
7213        );
7214        let ocm_state = Arc::new(Mutex::new(state));
7215        let (emitter, mut rx) = emitter_with_receiver(account_id);
7216        let order = cancel_unmatched_order(bet_id, Some(suffix.to_string()));
7217
7218        let processed = BetfairExecutionClient::process_unmatched_order(
7219            &order,
7220            InstrumentId::from("1.234567-12345-0.0.BETFAIR"),
7221            account_id,
7222            Currency::GBP(),
7223            &emitter,
7224            &ocm_state,
7225            UnixNanos::from(1),
7226            UnixNanos::from(1),
7227        );
7228        let report = match rx.try_recv().unwrap() {
7229            ExecutionEvent::Report(ExecutionReport::Order(report)) => *report,
7230            other => panic!("expected fail-closed order report, was {other:?}"),
7231        };
7232
7233        let mut state = ocm_state.lock();
7234        for index in 0..=OcmState::DEDUP_RETENTION {
7235            state.mark_terminal_order(format!("external-bet-{index}"));
7236        }
7237        let replay = state.fill_tracker.advance_cumulative_fill(
7238            bet_id,
7239            Decimal::from(2),
7240            Some(Decimal::from(3)),
7241            Decimal::from(3),
7242        );
7243        let mut reports = vec![report];
7244        let updates = resolve_pending_modifies_in_state(
7245            &mut reports,
7246            &AHashMap::new(),
7247            &AHashMap::new(),
7248            &mut state,
7249            &emitter,
7250            None,
7251        );
7252
7253        assert!(processed);
7254        assert!(updates.is_empty());
7255        assert_eq!(reports.len(), 1);
7256        assert_eq!(reports[0].client_order_id, None);
7257        assert_eq!(reports[0].venue_order_id, VenueOrderId::from(bet_id));
7258        assert_eq!(
7259            state.order_strategy_id(&first),
7260            Some(StrategyId::from("S-FIRST"))
7261        );
7262        assert!(state.should_suppress_cancel(&first, bet_id));
7263        assert!(state.pending_replace_awaits_reconciliation(&first, bet_id));
7264        assert!(!state.is_retained_terminal_order(&first));
7265        assert!(state.terminal_orders.contains(bet_id));
7266        assert!(replay.is_none());
7267        assert!(rx.try_recv().is_err());
7268    }
7269
7270    #[rstest]
7271    fn test_ambiguous_customer_order_ref_bounds_known_current_terminal_identity() {
7272        let account_id = AccountId::from("BETFAIR-001");
7273        let suffix = "12345678901234567890123456789012";
7274        let first = ClientOrderId::from(format!("FIRST-{suffix}"));
7275        let second = ClientOrderId::from(format!("SECOND-{suffix}"));
7276        let bet_id = "bet-first";
7277        let mut state = OcmState::default();
7278        state.restore_order(
7279            first,
7280            StrategyId::from("S-FIRST"),
7281            VenueOrderId::from(bet_id),
7282        );
7283        state.restore_order(
7284            second,
7285            StrategyId::from("S-SECOND"),
7286            VenueOrderId::from("bet-second"),
7287        );
7288        let ocm_state = Arc::new(Mutex::new(state));
7289        let (emitter, mut rx) = emitter_with_receiver(account_id);
7290        let order = cancel_unmatched_order(bet_id, Some(suffix.to_string()));
7291
7292        let processed = BetfairExecutionClient::process_unmatched_order(
7293            &order,
7294            InstrumentId::from("1.234567-12345-0.0.BETFAIR"),
7295            account_id,
7296            Currency::GBP(),
7297            &emitter,
7298            &ocm_state,
7299            UnixNanos::from(1),
7300            UnixNanos::from(1),
7301        );
7302        let report = match rx.try_recv().unwrap() {
7303            ExecutionEvent::Report(ExecutionReport::Order(report)) => report,
7304            other => panic!("expected fail-closed order report, was {other:?}"),
7305        };
7306
7307        let mut state = ocm_state.lock();
7308        assert!(state.is_retained_terminal_order(&first));
7309        for index in 0..OcmState::DEDUP_RETENTION {
7310            state.mark_terminal_order(format!("external-bet-{index}"));
7311        }
7312
7313        assert!(processed);
7314        assert_eq!(report.client_order_id, None);
7315        assert_eq!(report.venue_order_id, VenueOrderId::from(bet_id));
7316        assert_eq!(state.order_strategy_id(&first), None);
7317        assert!(!state.terminal_orders.contains(bet_id));
7318        assert!(rx.try_recv().is_err());
7319    }
7320
7321    #[rstest]
7322    fn test_untracked_order_with_fill_reports_with_resolved_id() {
7323        // Resolved rfo but untracked: the fill is reported with the resolved
7324        // client_order_id patched on.
7325        let account_id = AccountId::from("BETFAIR-001");
7326        let client_order_id = ClientOrderId::from("O-EXT-FILL");
7327
7328        let mut inner = OcmState::default();
7329        inner.register_order_ref(client_order_id).unwrap();
7330        let ocm_state = Arc::new(Mutex::new(inner));
7331
7332        let (emitter, mut rx) = emitter_with_receiver(account_id);
7333        let rfo = make_customer_order_ref(client_order_id.as_str());
7334        let uo = fill_unmatched_order("bet_ext_fill", Some(rfo), Decimal::new(10, 0));
7335
7336        let processed = BetfairExecutionClient::process_unmatched_order(
7337            &uo,
7338            InstrumentId::from("1.234567-12345-0.0.BETFAIR"),
7339            account_id,
7340            Currency::from("GBP"),
7341            &emitter,
7342            &ocm_state,
7343            UnixNanos::default(),
7344            UnixNanos::default(),
7345        );
7346
7347        assert!(processed);
7348
7349        match rx.try_recv().expect("expected a fill report") {
7350            ExecutionEvent::Report(ExecutionReport::Fill(fill)) => {
7351                assert_eq!(fill.client_order_id, Some(client_order_id));
7352                assert_eq!(fill.last_qty.as_decimal(), Decimal::new(10, 0));
7353            }
7354            other => panic!("expected a FillReport for untracked fill, was {other:?}"),
7355        }
7356
7357        match rx.try_recv().expect("expected a status report") {
7358            ExecutionEvent::Report(ExecutionReport::Order(_)) => {}
7359            other => panic!("expected an OrderStatusReport, was {other:?}"),
7360        }
7361    }
7362
7363    #[rstest]
7364    fn test_unparsable_order_returns_false_without_emitting() {
7365        let account_id = AccountId::from("BETFAIR-001");
7366        let ocm_state = Arc::new(Mutex::new(OcmState::default()));
7367        let (emitter, mut rx) = emitter_with_receiver(account_id);
7368
7369        let mut uo = cancel_unmatched_order("bet_bad", None);
7370        uo.pt = None; // LIMIT without persistence type -> parse error
7371
7372        let processed = BetfairExecutionClient::process_unmatched_order(
7373            &uo,
7374            InstrumentId::from("1.234567-12345-0.0.BETFAIR"),
7375            account_id,
7376            Currency::from("GBP"),
7377            &emitter,
7378            &ocm_state,
7379            UnixNanos::default(),
7380            UnixNanos::default(),
7381        );
7382
7383        assert!(!processed);
7384        assert!(rx.try_recv().is_err(), "unparsable order must emit nothing");
7385    }
7386
7387    #[rstest]
7388    fn test_process_ocm_voided_emits_custom_data() {
7389        // An ExecutionComplete order with size_voided > 0 publishes a
7390        // BetfairOrderVoided custom data event.
7391        let data = crate::common::testing::load_test_json("stream/ocm_VOIDED.json");
7392        let ocm = match crate::stream::messages::stream_decode(data.as_bytes()).unwrap() {
7393            crate::stream::messages::StreamMessage::OrderChange(ocm) => ocm,
7394            other => panic!("expected an OCM stream message, was {other:?}"),
7395        };
7396
7397        let account_id = AccountId::from("BETFAIR-001");
7398        let ocm_state = Arc::new(Mutex::new(OcmState::default()));
7399        let (emitter, _rx) = emitter_with_receiver(account_id);
7400        let (data_tx, mut data_rx) = tokio::sync::mpsc::unbounded_channel();
7401        let (account_refresh_tx, mut account_refresh_rx) = tokio::sync::mpsc::unbounded_channel();
7402
7403        let received = ReceivedOcm {
7404            message: ocm,
7405            ts_init: UnixNanos::from(1_800_000_000_000_000_004),
7406        };
7407
7408        BetfairExecutionClient::process_ocm(
7409            &received,
7410            account_id,
7411            Currency::from("GBP"),
7412            &emitter,
7413            &ocm_state,
7414            &data_tx.into(),
7415            None,
7416            false,
7417            Some(&account_refresh_tx),
7418        );
7419
7420        let voided = std::iter::from_fn(|| data_rx.try_recv().ok())
7421            .any(|event| matches!(event, DataEvent::Data(Data::Custom(_))));
7422        assert!(voided, "voided OCM must publish a custom voided data event");
7423        assert!(account_refresh_rx.try_recv().is_ok());
7424    }
7425
7426    #[rstest]
7427    #[case("stream/ocm_VOIDED.json", Decimal::new(50, 0), Decimal::new(50, 0))]
7428    #[case(
7429        "stream/ocm_VOIDED_partial.json",
7430        Decimal::new(60, 0),
7431        Decimal::new(40, 0)
7432    )]
7433    fn test_tracked_void_fixture_emits_terminal_fill_correction(
7434        #[case] fixture: &str,
7435        #[case] matched: Decimal,
7436        #[case] voided: Decimal,
7437    ) {
7438        let data = crate::common::testing::load_test_json(fixture);
7439        let ocm = match crate::stream::messages::stream_decode(data.as_bytes()).unwrap() {
7440            crate::stream::messages::StreamMessage::OrderChange(ocm) => ocm,
7441            other => panic!("expected an OCM stream message, was {other:?}"),
7442        };
7443        let market = &ocm.oc.as_ref().unwrap()[0];
7444        let runner = &market.orc.as_ref().unwrap()[0];
7445        let uo = &runner.uo.as_ref().unwrap()[0];
7446        let client_order_id = ClientOrderId::from(uo.rfo.as_deref().unwrap());
7447        let strategy_id = StrategyId::from("S-VOID");
7448        let account_id = AccountId::from("BETFAIR-001");
7449        let mut inner = OcmState::default();
7450        inner
7451            .register_submission(client_order_id, strategy_id)
7452            .unwrap();
7453        inner.mark_accepted(client_order_id);
7454        let state = Arc::new(Mutex::new(inner));
7455        let (emitter, mut rx) = emitter_with_receiver(account_id);
7456
7457        let processed = BetfairExecutionClient::process_unmatched_order(
7458            uo,
7459            make_instrument_id(&market.id, runner.id, Decimal::ZERO),
7460            account_id,
7461            Currency::GBP(),
7462            &emitter,
7463            &state,
7464            parse_millis_timestamp(ocm.pt),
7465            parse_millis_timestamp(ocm.pt),
7466        );
7467
7468        let filled = match rx.try_recv().unwrap() {
7469            ExecutionEvent::Order(OrderEventAny::Filled(event)) => event,
7470            other => panic!("expected OrderFilled, was {other:?}"),
7471        };
7472        let fill_voided = match rx.try_recv().unwrap() {
7473            ExecutionEvent::Order(OrderEventAny::FillVoided(event)) => event,
7474            other => panic!("expected OrderFillVoided, was {other:?}"),
7475        };
7476        assert!(processed);
7477        assert_eq!(filled.last_qty.as_decimal(), matched);
7478        assert_ne!(fill_voided.trade_id, filled.trade_id);
7479        assert_eq!(fill_voided.voided_qty.as_decimal(), voided);
7480        assert_eq!(fill_voided.commission_voided, None);
7481        assert!(!fill_voided.is_reopened);
7482        assert_eq!(fill_voided.causation_id, Some(filled.event_id));
7483        assert!(rx.try_recv().is_err());
7484    }
7485
7486    #[rstest]
7487    fn test_terminal_bet_allows_increased_cumulative_void_report() {
7488        let data = crate::common::testing::load_test_json("stream/ocm_VOIDED_partial.json");
7489        let ocm = match crate::stream::messages::stream_decode(data.as_bytes()).unwrap() {
7490            crate::stream::messages::StreamMessage::OrderChange(ocm) => ocm,
7491            other => panic!("expected an OCM stream message, was {other:?}"),
7492        };
7493        let market = &ocm.oc.as_ref().unwrap()[0];
7494        let runner = &market.orc.as_ref().unwrap()[0];
7495        let mut uo = runner.uo.as_ref().unwrap()[0].clone();
7496        let client_order_id = ClientOrderId::from(uo.rfo.as_deref().unwrap());
7497        let account_id = AccountId::from("BETFAIR-001");
7498        let mut inner = OcmState::default();
7499        inner
7500            .register_submission(client_order_id, StrategyId::from("S-VOID"))
7501            .unwrap();
7502        inner.mark_accepted(client_order_id);
7503        let state = Arc::new(Mutex::new(inner));
7504        let (emitter, mut rx) = emitter_with_receiver(account_id);
7505        let instrument_id = make_instrument_id(&market.id, runner.id, Decimal::ZERO);
7506        let ts = parse_millis_timestamp(ocm.pt);
7507
7508        let first = BetfairExecutionClient::process_unmatched_order(
7509            &uo,
7510            instrument_id,
7511            account_id,
7512            Currency::GBP(),
7513            &emitter,
7514            &state,
7515            ts,
7516            ts,
7517        );
7518        let first_events = std::iter::from_fn(|| rx.try_recv().ok()).collect::<Vec<_>>();
7519        uo.sm = Some(Decimal::new(50, 0));
7520        uo.sv = Some(Decimal::new(50, 0));
7521        let increased = BetfairExecutionClient::process_unmatched_order(
7522            &uo,
7523            instrument_id,
7524            account_id,
7525            Currency::GBP(),
7526            &emitter,
7527            &state,
7528            ts,
7529            ts,
7530        );
7531        let fill_voided = match rx.try_recv().unwrap() {
7532            ExecutionEvent::Order(OrderEventAny::FillVoided(fill_voided)) => fill_voided,
7533            other => panic!("expected a direct fill void correction, was {other:?}"),
7534        };
7535        let duplicate = BetfairExecutionClient::process_unmatched_order(
7536            &uo,
7537            instrument_id,
7538            account_id,
7539            Currency::GBP(),
7540            &emitter,
7541            &state,
7542            ts,
7543            ts,
7544        );
7545
7546        assert!(first);
7547        assert_eq!(first_events.len(), 2);
7548        assert!(increased);
7549        assert_eq!(fill_voided.client_order_id, client_order_id);
7550        assert_eq!(fill_voided.strategy_id, StrategyId::from("S-VOID"));
7551        assert_eq!(
7552            fill_voided.venue_order_id,
7553            VenueOrderId::from(uo.id.as_str()),
7554        );
7555        assert_eq!(fill_voided.voided_qty, Quantity::from("10.00"));
7556        assert!(!duplicate);
7557        assert!(rx.try_recv().is_err());
7558    }
7559
7560    #[rstest]
7561    fn test_retained_terminal_order_routes_late_fill_and_void_by_bet_id() {
7562        let client_order_id = ClientOrderId::from("O-LATE-FILL");
7563        let strategy_id = StrategyId::from("S-001");
7564        let account_id = AccountId::from("BETFAIR-001");
7565        let bet_id = "late-fill-bet";
7566        let mut inner = OcmState::default();
7567        inner
7568            .register_submission(client_order_id, strategy_id)
7569            .unwrap();
7570        inner.mark_accepted(client_order_id);
7571        inner.bind_venue_order_id(&client_order_id, VenueOrderId::from(bet_id));
7572        let state = Arc::new(Mutex::new(inner));
7573        let (emitter, mut rx) = emitter_with_receiver(account_id);
7574        let instrument_id = InstrumentId::from("1.234567-12345-0.0.BETFAIR");
7575        let mut terminal = cancel_unmatched_order(
7576            bet_id,
7577            Some(make_customer_order_ref(client_order_id.as_str())),
7578        );
7579
7580        let first = BetfairExecutionClient::process_unmatched_order(
7581            &terminal,
7582            instrument_id,
7583            account_id,
7584            Currency::GBP(),
7585            &emitter,
7586            &state,
7587            UnixNanos::from(1),
7588            UnixNanos::from(1),
7589        );
7590        let canceled = match rx.try_recv().unwrap() {
7591            ExecutionEvent::Order(OrderEventAny::Canceled(canceled)) => canceled,
7592            other => panic!("expected initial cancel, was {other:?}"),
7593        };
7594
7595        terminal.rfo = None;
7596        terminal.sm = Some(Decimal::from(2));
7597        terminal.sc = Some(Decimal::from(18));
7598        terminal.avp = Some(Decimal::from(3));
7599        let late = BetfairExecutionClient::process_unmatched_order(
7600            &terminal,
7601            instrument_id,
7602            account_id,
7603            Currency::GBP(),
7604            &emitter,
7605            &state,
7606            UnixNanos::from(2),
7607            UnixNanos::from(2),
7608        );
7609        let filled = match rx.try_recv().unwrap() {
7610            ExecutionEvent::Order(OrderEventAny::Filled(filled)) => filled,
7611            other => panic!("expected direct late fill, was {other:?}"),
7612        };
7613        let reclosed = match rx.try_recv().unwrap() {
7614            ExecutionEvent::Order(OrderEventAny::Canceled(canceled)) => canceled,
7615            other => panic!("expected re-close after late fill, was {other:?}"),
7616        };
7617        let duplicate = BetfairExecutionClient::process_unmatched_order(
7618            &terminal,
7619            instrument_id,
7620            account_id,
7621            Currency::GBP(),
7622            &emitter,
7623            &state,
7624            UnixNanos::from(3),
7625            UnixNanos::from(3),
7626        );
7627
7628        terminal.sv = Some(Decimal::from(2));
7629        terminal.sc = Some(Decimal::from(16));
7630        let corrected = BetfairExecutionClient::process_unmatched_order(
7631            &terminal,
7632            instrument_id,
7633            account_id,
7634            Currency::GBP(),
7635            &emitter,
7636            &state,
7637            UnixNanos::from(4),
7638            UnixNanos::from(4),
7639        );
7640        let correction_fill = match rx.try_recv().unwrap() {
7641            ExecutionEvent::Order(OrderEventAny::Filled(filled)) => filled,
7642            other => panic!("expected fill preceding correction, was {other:?}"),
7643        };
7644        let correction_reclose = match rx.try_recv().unwrap() {
7645            ExecutionEvent::Order(OrderEventAny::Canceled(canceled)) => canceled,
7646            other => panic!("expected re-close preceding correction, was {other:?}"),
7647        };
7648        let fill_voided = match rx.try_recv().unwrap() {
7649            ExecutionEvent::Order(OrderEventAny::FillVoided(fill_voided)) => fill_voided,
7650            other => panic!("expected direct fill void correction, was {other:?}"),
7651        };
7652        let correction_duplicate = BetfairExecutionClient::process_unmatched_order(
7653            &terminal,
7654            instrument_id,
7655            account_id,
7656            Currency::GBP(),
7657            &emitter,
7658            &state,
7659            UnixNanos::from(5),
7660            UnixNanos::from(5),
7661        );
7662
7663        assert!(first);
7664        assert!(late);
7665        assert_eq!(canceled.client_order_id, client_order_id);
7666        assert_eq!(filled.client_order_id, client_order_id);
7667        assert_eq!(filled.strategy_id, strategy_id);
7668        assert_eq!(filled.venue_order_id, VenueOrderId::from(bet_id));
7669        assert_eq!(filled.last_qty, Quantity::from("2.00"));
7670        assert_eq!(reclosed.client_order_id, client_order_id);
7671        assert!(!duplicate);
7672        assert!(corrected);
7673        assert_eq!(correction_fill.client_order_id, client_order_id);
7674        assert_eq!(correction_fill.last_qty, Quantity::from("2.00"));
7675        assert_eq!(correction_reclose.client_order_id, client_order_id);
7676        assert_eq!(fill_voided.client_order_id, client_order_id);
7677        assert_eq!(fill_voided.strategy_id, strategy_id);
7678        assert_eq!(fill_voided.venue_order_id, VenueOrderId::from(bet_id));
7679        assert_eq!(fill_voided.voided_qty, Quantity::from("2.00"));
7680        assert_eq!(fill_voided.causation_id, Some(correction_fill.event_id));
7681        assert!(!correction_duplicate);
7682        assert!(rx.try_recv().is_err());
7683    }
7684
7685    #[rstest]
7686    fn test_retained_terminal_price_restatement_does_not_reclose() {
7687        let client_order_id = ClientOrderId::from("O-RULE4-LAPSE");
7688        let strategy_id = StrategyId::from("S-001");
7689        let account_id = AccountId::from("BETFAIR-001");
7690        let bet_id = "rule4-lapse-bet";
7691        let mut inner = OcmState::default();
7692        inner
7693            .register_submission(client_order_id, strategy_id)
7694            .unwrap();
7695        inner.mark_accepted(client_order_id);
7696        inner.bind_venue_order_id(&client_order_id, VenueOrderId::from(bet_id));
7697        let state = Arc::new(Mutex::new(inner));
7698        let (emitter, mut rx) = emitter_with_receiver(account_id);
7699        let instrument_id = InstrumentId::from("1.234567-12345-0.0.BETFAIR");
7700        let mut terminal = cancel_unmatched_order(
7701            bet_id,
7702            Some(make_customer_order_ref(client_order_id.as_str())),
7703        );
7704        terminal.sm = Some(Decimal::from(2));
7705        terminal.sc = Some(Decimal::from(18));
7706        terminal.avp = Some(Decimal::from(12));
7707
7708        assert!(BetfairExecutionClient::process_unmatched_order(
7709            &terminal,
7710            instrument_id,
7711            account_id,
7712            Currency::GBP(),
7713            &emitter,
7714            &state,
7715            UnixNanos::from(1),
7716            UnixNanos::from(1),
7717        ));
7718        let opened = std::iter::from_fn(|| rx.try_recv().ok()).collect::<Vec<_>>();
7719        assert!(
7720            opened
7721                .iter()
7722                .any(|event| matches!(event, ExecutionEvent::Order(OrderEventAny::Filled(_))))
7723        );
7724        assert!(
7725            opened
7726                .iter()
7727                .any(|event| matches!(event, ExecutionEvent::Order(OrderEventAny::Canceled(_))))
7728        );
7729
7730        terminal.avp = Some(Decimal::new(947, 2));
7731        assert!(BetfairExecutionClient::process_unmatched_order(
7732            &terminal,
7733            instrument_id,
7734            account_id,
7735            Currency::GBP(),
7736            &emitter,
7737            &state,
7738            UnixNanos::from(2),
7739            UnixNanos::from(2),
7740        ));
7741
7742        let restated = match rx.try_recv().expect("price restatement") {
7743            ExecutionEvent::Order(OrderEventAny::Filled(filled)) => filled,
7744            other => panic!("expected a price restatement, was {other:?}"),
7745        };
7746
7747        assert_eq!(restated.client_order_id, client_order_id);
7748        assert_eq!(restated.last_px, Price::from("9.47"));
7749        assert_eq!(restated.last_qty, Quantity::from("2.00"));
7750        assert!(rx.try_recv().is_err());
7751    }
7752
7753    #[rstest]
7754    fn test_retained_terminal_all_void_correction_does_not_reclose() {
7755        let client_order_id = ClientOrderId::from("O-ALL-VOID");
7756        let strategy_id = StrategyId::from("S-001");
7757        let account_id = AccountId::from("BETFAIR-001");
7758        let bet_id = "all-void-bet";
7759        let mut inner = OcmState::default();
7760        inner.restore_order(client_order_id, strategy_id, VenueOrderId::from(bet_id));
7761        inner.fill_tracker.advance_cumulative_fill(
7762            bet_id,
7763            Decimal::from(2),
7764            Some(Decimal::from(3)),
7765            Decimal::from(3),
7766        );
7767        inner.retain_terminal_order(client_order_id, bet_id);
7768        let state = Arc::new(Mutex::new(inner));
7769        let (emitter, mut rx) = emitter_with_receiver(account_id);
7770        let instrument_id = InstrumentId::from("1.234567-12345-0.0.BETFAIR");
7771        let mut correction = cancel_unmatched_order(bet_id, None);
7772        correction.sm = Some(Decimal::ZERO);
7773        correction.sc = None;
7774        correction.sv = Some(Decimal::from(4));
7775        correction.avp = Some(Decimal::from(3));
7776
7777        let processed = BetfairExecutionClient::process_unmatched_order(
7778            &correction,
7779            instrument_id,
7780            account_id,
7781            Currency::GBP(),
7782            &emitter,
7783            &state,
7784            UnixNanos::from(1),
7785            UnixNanos::from(1),
7786        );
7787        let events = std::iter::from_fn(|| rx.try_recv().ok()).collect::<Vec<_>>();
7788        let duplicate = BetfairExecutionClient::process_unmatched_order(
7789            &correction,
7790            instrument_id,
7791            account_id,
7792            Currency::GBP(),
7793            &emitter,
7794            &state,
7795            UnixNanos::from(2),
7796            UnixNanos::from(2),
7797        );
7798
7799        assert!(processed);
7800        assert_eq!(events.len(), 3);
7801        assert!(matches!(
7802            &events[0],
7803            ExecutionEvent::Order(OrderEventAny::Filled(filled))
7804                if filled.client_order_id == client_order_id
7805                    && filled.last_qty == Quantity::from("2.00")
7806        ));
7807        assert!(matches!(
7808            &events[1],
7809            ExecutionEvent::Order(OrderEventAny::FillVoided(fill_voided))
7810                if fill_voided.client_order_id == client_order_id
7811                    && fill_voided.voided_qty == Quantity::from("2.00")
7812        ));
7813        assert!(matches!(
7814            &events[2],
7815            ExecutionEvent::Order(OrderEventAny::FillVoided(fill_voided))
7816                if fill_voided.client_order_id == client_order_id
7817                    && fill_voided.voided_qty == Quantity::from("2.00")
7818        ));
7819        assert!(!duplicate);
7820        assert!(rx.try_recv().is_err());
7821    }
7822
7823    fn fill_unmatched_order(
7824        bet_id: &str,
7825        rfo: Option<String>,
7826        size_matched: Decimal,
7827    ) -> crate::stream::messages::UnmatchedOrder {
7828        crate::stream::messages::UnmatchedOrder {
7829            id: bet_id.to_string(),
7830            p: Decimal::new(20, 1),
7831            s: Decimal::new(20, 0),
7832            side: crate::common::enums::StreamingSide::Back,
7833            status: crate::common::enums::StreamingOrderStatus::Executable,
7834            pt: Some(crate::common::enums::StreamingPersistenceType::Lapse),
7835            ot: crate::common::enums::StreamingOrderType::Limit,
7836            pd: 1617863365000,
7837            bsp: None,
7838            rfo,
7839            rfs: None,
7840            rc: None,
7841            rac: None,
7842            md: None,
7843            cd: None,
7844            ld: None,
7845            avp: Some(Decimal::new(20, 1)),
7846            sm: Some(size_matched),
7847            sr: None,
7848            sl: None,
7849            sc: None,
7850            sv: None,
7851            lsrc: None,
7852        }
7853    }
7854
7855    #[rstest]
7856    fn test_tracked_fill_synthesizes_accept_then_emits_filled() {
7857        // First OCM is a fill with no prior accept: synthesize OrderAccepted, then OrderFilled.
7858        let account_id = AccountId::from("BETFAIR-001");
7859        let client_order_id = ClientOrderId::from("O-FILL-100");
7860        let strategy_id = StrategyId::from("S-QUOTER");
7861
7862        let mut inner = OcmState::default();
7863        inner
7864            .register_submission(client_order_id, strategy_id)
7865            .unwrap();
7866        let ocm_state = Arc::new(Mutex::new(inner));
7867
7868        let (emitter, mut rx) = emitter_with_receiver(account_id);
7869        let rfo = make_customer_order_ref(client_order_id.as_str());
7870        let uo = fill_unmatched_order("bet_fill", Some(rfo), Decimal::new(10, 0));
7871
7872        let processed = BetfairExecutionClient::process_unmatched_order(
7873            &uo,
7874            InstrumentId::from("1.234567-12345-0.0.BETFAIR"),
7875            account_id,
7876            Currency::from("GBP"),
7877            &emitter,
7878            &ocm_state,
7879            UnixNanos::default(),
7880            UnixNanos::default(),
7881        );
7882
7883        assert!(processed);
7884
7885        match rx.try_recv().expect("expected an accepted event") {
7886            ExecutionEvent::Order(OrderEventAny::Accepted(accepted)) => {
7887                assert_eq!(accepted.client_order_id, client_order_id);
7888                assert_eq!(accepted.strategy_id, strategy_id);
7889            }
7890            other => panic!("expected a synthesized OrderAccepted, was {other:?}"),
7891        }
7892
7893        match rx.try_recv().expect("expected a filled event") {
7894            ExecutionEvent::Order(OrderEventAny::Filled(filled)) => {
7895                assert_eq!(filled.client_order_id, client_order_id);
7896                assert_eq!(filled.strategy_id, strategy_id);
7897                assert_eq!(filled.venue_order_id, VenueOrderId::from("bet_fill"));
7898                assert_eq!(filled.last_qty.as_decimal(), Decimal::new(10, 0));
7899            }
7900            other => panic!("expected a direct OrderFilled event, was {other:?}"),
7901        }
7902
7903        assert!(
7904            rx.try_recv().is_err(),
7905            "tracked fill must not also emit a report",
7906        );
7907    }
7908
7909    #[rstest]
7910    fn test_tracked_fill_on_accepted_order_skips_synth_accept() {
7911        // Already accepted via HTTP ack: the tracked fill emits only OrderFilled,
7912        // no duplicate accept.
7913        let account_id = AccountId::from("BETFAIR-001");
7914        let client_order_id = ClientOrderId::from("O-FILL-200");
7915        let strategy_id = StrategyId::from("S-QUOTER");
7916
7917        let mut inner = OcmState::default();
7918        inner
7919            .register_submission(client_order_id, strategy_id)
7920            .unwrap();
7921        inner.mark_accepted(client_order_id); // already accepted via HTTP place ack
7922        let ocm_state = Arc::new(Mutex::new(inner));
7923
7924        let (emitter, mut rx) = emitter_with_receiver(account_id);
7925        let rfo = make_customer_order_ref(client_order_id.as_str());
7926        let uo = fill_unmatched_order("bet_fill2", Some(rfo), Decimal::new(10, 0));
7927
7928        let processed = BetfairExecutionClient::process_unmatched_order(
7929            &uo,
7930            InstrumentId::from("1.234567-12345-0.0.BETFAIR"),
7931            account_id,
7932            Currency::from("GBP"),
7933            &emitter,
7934            &ocm_state,
7935            UnixNanos::default(),
7936            UnixNanos::default(),
7937        );
7938
7939        assert!(processed);
7940
7941        match rx.try_recv().expect("expected a filled event") {
7942            ExecutionEvent::Order(OrderEventAny::Filled(filled)) => {
7943                assert_eq!(filled.client_order_id, client_order_id);
7944                assert_eq!(filled.last_qty.as_decimal(), Decimal::new(10, 0));
7945            }
7946            other => panic!("expected OrderFilled with no preceding accept, was {other:?}"),
7947        }
7948
7949        assert!(
7950            rx.try_recv().is_err(),
7951            "already-accepted order must not re-synthesize OrderAccepted",
7952        );
7953    }
7954
7955    #[rstest]
7956    fn test_rule4_average_restatement_keeps_filled_quantity_and_original_void_price() {
7957        let account_id = AccountId::from("BETFAIR-001");
7958        let client_order_id = ClientOrderId::from("O-RULE4");
7959        let strategy_id = StrategyId::from("S-RULE4");
7960        let instrument_id = InstrumentId::from("1.234567-12345-0.0.BETFAIR");
7961        let mut inner = OcmState::default();
7962        inner
7963            .register_submission(client_order_id, strategy_id)
7964            .unwrap();
7965        let state = Arc::new(Mutex::new(inner));
7966        let (emitter, mut rx) = emitter_with_receiver(account_id);
7967        let rfo = make_customer_order_ref(client_order_id.as_str());
7968        let mut uo = fill_unmatched_order("bet-rule4", Some(rfo), Decimal::from(2));
7969        uo.s = Decimal::from(2);
7970        uo.status = crate::common::enums::StreamingOrderStatus::ExecutionComplete;
7971        uo.avp = Some(Decimal::from(12));
7972
7973        assert!(BetfairExecutionClient::process_unmatched_order(
7974            &uo,
7975            instrument_id,
7976            account_id,
7977            Currency::GBP(),
7978            &emitter,
7979            &state,
7980            UnixNanos::from(1),
7981            UnixNanos::from(1),
7982        ));
7983        let opened = std::iter::from_fn(|| rx.try_recv().ok()).collect::<Vec<_>>();
7984
7985        let accepted = opened.iter().find_map(|event| match event {
7986            ExecutionEvent::Order(OrderEventAny::Accepted(accepted)) => Some(*accepted),
7987            _ => None,
7988        });
7989
7990        let filled = opened.iter().find_map(|event| match event {
7991            ExecutionEvent::Order(OrderEventAny::Filled(filled)) => Some(filled.clone()),
7992            _ => None,
7993        });
7994
7995        let accepted = accepted.expect("synthesized accept");
7996        let filled = filled.expect("initial fill");
7997
7998        uo.avp = Some(Decimal::new(947, 2));
7999        assert!(BetfairExecutionClient::process_unmatched_order(
8000            &uo,
8001            instrument_id,
8002            account_id,
8003            Currency::GBP(),
8004            &emitter,
8005            &state,
8006            UnixNanos::from(2),
8007            UnixNanos::from(2),
8008        ));
8009
8010        let restatement = match rx.try_recv().expect("price restatement") {
8011            ExecutionEvent::Order(OrderEventAny::Filled(filled)) => filled,
8012            other => panic!("expected a price restatement, was {other:?}"),
8013        };
8014
8015        assert!(rx.try_recv().is_err());
8016
8017        let repeat = BetfairExecutionClient::process_unmatched_order(
8018            &uo,
8019            instrument_id,
8020            account_id,
8021            Currency::GBP(),
8022            &emitter,
8023            &state,
8024            UnixNanos::from(3),
8025            UnixNanos::from(3),
8026        );
8027        assert!(!repeat);
8028        assert!(rx.try_recv().is_err());
8029
8030        uo.sm = Some(Decimal::ZERO);
8031        uo.sv = Some(Decimal::from(2));
8032        assert!(BetfairExecutionClient::process_unmatched_order(
8033            &uo,
8034            instrument_id,
8035            account_id,
8036            Currency::GBP(),
8037            &emitter,
8038            &state,
8039            UnixNanos::from(4),
8040            UnixNanos::from(4),
8041        ));
8042
8043        let voided = std::iter::from_fn(|| rx.try_recv().ok()).find_map(|event| match event {
8044            ExecutionEvent::Order(OrderEventAny::FillVoided(voided)) => Some(voided),
8045            _ => None,
8046        });
8047
8048        let voided = voided.expect("fill void");
8049
8050        let mut order = OrderTestBuilder::new(OrderType::Limit)
8051            .trader_id(TraderId::from("TESTER-001"))
8052            .strategy_id(strategy_id)
8053            .instrument_id(instrument_id)
8054            .client_order_id(client_order_id)
8055            .side(OrderSide::Sell)
8056            .quantity(Quantity::from("2.00"))
8057            .price(Price::from("12.00"))
8058            .build();
8059        order.apply(OrderEventAny::Accepted(accepted)).unwrap();
8060        order.apply(OrderEventAny::Filled(filled.clone())).unwrap();
8061        order
8062            .apply(OrderEventAny::Filled(restatement.clone()))
8063            .unwrap();
8064
8065        let audusd = audusd_sim();
8066        let position_id = PositionId::from("P-RULE4");
8067        let mut opening = filled.clone();
8068        opening.instrument_id = audusd.id();
8069        opening.position_id = Some(position_id);
8070        let mut restated_fill = restatement.clone();
8071        restated_fill.instrument_id = audusd.id();
8072        restated_fill.position_id = Some(position_id);
8073        let mut position = Position::new(&InstrumentAny::CurrencyPair(audusd), opening);
8074        position.apply(&restated_fill);
8075
8076        assert_eq!(restatement.trade_id, filled.trade_id);
8077        assert_eq!(restatement.last_qty.as_decimal(), dec!(2));
8078        assert_eq!(restatement.last_px.as_decimal(), dec!(9.47));
8079        assert_eq!(order.status(), OrderStatus::Filled);
8080        assert_eq!(order.filled_qty().as_decimal(), dec!(2));
8081        assert!(order.leaves_qty().is_zero());
8082        assert_eq!(order.avg_px(), Some(dec!(9.47)));
8083        assert_eq!(filled.last_px.as_decimal(), dec!(12));
8084        assert_eq!(position.quantity.as_decimal(), dec!(2));
8085        assert_eq!(position.avg_px_open, restatement.last_px.as_decimal());
8086        assert_eq!(position.events[0].last_px, filled.last_px);
8087        assert_eq!(voided.trade_id, filled.trade_id);
8088        assert_eq!(voided.last_px, filled.last_px);
8089        order.apply(OrderEventAny::FillVoided(voided)).unwrap();
8090    }
8091
8092    #[rstest]
8093    fn test_rule4_restatement_prices_later_fill_from_corrected_average() {
8094        let account_id = AccountId::from("BETFAIR-001");
8095        let client_order_id = ClientOrderId::from("O-RULE4-PARTIAL");
8096        let strategy_id = StrategyId::from("S-RULE4");
8097        let instrument_id = InstrumentId::from("1.234567-12345-0.0.BETFAIR");
8098        let mut inner = OcmState::default();
8099        inner
8100            .register_submission(client_order_id, strategy_id)
8101            .unwrap();
8102        inner.mark_accepted(client_order_id);
8103        let state = Arc::new(Mutex::new(inner));
8104        let (emitter, mut rx) = emitter_with_receiver(account_id);
8105        let rfo = make_customer_order_ref(client_order_id.as_str());
8106        let mut uo = fill_unmatched_order("bet-rule4-partial", Some(rfo), Decimal::from(2));
8107        uo.s = Decimal::from(4);
8108        uo.avp = Some(Decimal::from(12));
8109
8110        assert!(BetfairExecutionClient::process_unmatched_order(
8111            &uo,
8112            instrument_id,
8113            account_id,
8114            Currency::GBP(),
8115            &emitter,
8116            &state,
8117            UnixNanos::from(1),
8118            UnixNanos::from(1),
8119        ));
8120        let _ = std::iter::from_fn(|| rx.try_recv().ok()).collect::<Vec<_>>();
8121
8122        uo.avp = Some(Decimal::new(947, 2));
8123        assert!(BetfairExecutionClient::process_unmatched_order(
8124            &uo,
8125            instrument_id,
8126            account_id,
8127            Currency::GBP(),
8128            &emitter,
8129            &state,
8130            UnixNanos::from(2),
8131            UnixNanos::from(2),
8132        ));
8133        let _ = std::iter::from_fn(|| rx.try_recv().ok()).collect::<Vec<_>>();
8134
8135        uo.sm = Some(Decimal::from(4));
8136        uo.avp = Some(Decimal::from(10));
8137        assert!(BetfairExecutionClient::process_unmatched_order(
8138            &uo,
8139            instrument_id,
8140            account_id,
8141            Currency::GBP(),
8142            &emitter,
8143            &state,
8144            UnixNanos::from(3),
8145            UnixNanos::from(3),
8146        ));
8147
8148        let later = match rx.try_recv().expect("later fill") {
8149            ExecutionEvent::Order(OrderEventAny::Filled(filled)) => filled,
8150            other => panic!("expected the later fill, was {other:?}"),
8151        };
8152
8153        // (10 * 4 - 9.47 * 2) / 2 = 10.53
8154        assert_eq!(later.last_qty.as_decimal(), dec!(2));
8155        assert_eq!(later.last_px.as_decimal(), dec!(10.53));
8156    }
8157
8158    #[rstest]
8159    fn test_ocm_state_suppress_cancel_for_replaced() {
8160        let mut state = OcmState::default();
8161        let client_oid = ClientOrderId::from("O-001");
8162
8163        state.replaced_venue_order_ids.insert("old_bet".to_string());
8164        assert!(state.should_suppress_cancel(&client_oid, "old_bet"));
8165        assert!(!state.should_suppress_cancel(&client_oid, "new_bet"));
8166    }
8167
8168    #[rstest]
8169    fn test_ocm_state_suppress_cancel_for_pending_replace() {
8170        let mut state = OcmState::default();
8171        let client_oid = ClientOrderId::from("O-001");
8172
8173        state.register_pending_replace(client_oid, "old_bet".to_string(), None);
8174
8175        assert!(state.should_suppress_cancel(&client_oid, "old_bet"));
8176        assert!(!state.should_suppress_cancel(&client_oid, "other_bet"));
8177    }
8178
8179    #[rstest]
8180    fn test_ocm_state_retains_terminal_with_pending_replace() {
8181        let mut state = OcmState::default();
8182        let client_oid = ClientOrderId::from("O-001");
8183
8184        state.register_order_ref(client_oid).unwrap();
8185        state.register_pending_replace(client_oid, "old_bet".to_string(), None);
8186
8187        state.retain_terminal_order(client_oid, "old_bet");
8188        let rfo = make_customer_order_ref(client_oid.as_str());
8189        assert!(state.resolve_client_order_id(Some(&rfo)).is_some());
8190    }
8191
8192    #[rstest]
8193    fn test_ocm_state_retains_terminal_without_pending() {
8194        let mut state = OcmState::default();
8195        let client_oid = ClientOrderId::from("O-001");
8196
8197        state.register_order_ref(client_oid).unwrap();
8198
8199        state.retain_terminal_order(client_oid, "bet-1");
8200        let rfo = make_customer_order_ref(client_oid.as_str());
8201        assert_eq!(state.resolve_client_order_id(Some(&rfo)), Some(client_oid));
8202    }
8203
8204    #[rstest]
8205    fn test_ocm_state_sync_from_orders() {
8206        let mut state = OcmState::default();
8207
8208        let orders = vec![
8209            OrderSyncEntry {
8210                bet_id: "bet1".to_string(),
8211                venue_order_ids: vec!["bet1".to_string()],
8212                client_order_id: ClientOrderId::from("O-001"),
8213                strategy_id: StrategyId::from("S-001"),
8214                filled_qty: Decimal::new(10, 0),
8215                avg_px: Decimal::new(25, 1),
8216                is_closed: false,
8217                trade_ids: Vec::new(),
8218            },
8219            OrderSyncEntry {
8220                bet_id: "bet2".to_string(),
8221                venue_order_ids: vec!["bet2".to_string()],
8222                client_order_id: ClientOrderId::from("O-002"),
8223                strategy_id: StrategyId::from("S-001"),
8224                filled_qty: Decimal::new(5, 0),
8225                avg_px: Decimal::new(30, 1),
8226                is_closed: true,
8227                trade_ids: Vec::new(),
8228            },
8229        ];
8230
8231        state.sync_from_orders(&orders);
8232
8233        let open_client_order_id = ClientOrderId::from("O-001");
8234        let rfo1 = make_customer_order_ref("O-001");
8235        assert_eq!(
8236            state.resolve_client_order_id(Some(&rfo1)),
8237            Some(open_client_order_id),
8238        );
8239        assert_eq!(
8240            state.order_strategy_id(&open_client_order_id),
8241            Some(StrategyId::from("S-001")),
8242        );
8243        assert!(!state.mark_accepted(open_client_order_id));
8244
8245        assert!(state.terminal_orders.contains("bet2"));
8246        let rfo2 = make_customer_order_ref("O-002");
8247        assert_eq!(
8248            state.resolve_client_order_id(Some(&rfo2)),
8249            Some(ClientOrderId::from("O-002")),
8250        );
8251        assert_eq!(
8252            state.order_strategy_id(&ClientOrderId::from("O-002")),
8253            Some(StrategyId::from("S-001")),
8254        );
8255    }
8256
8257    #[rstest]
8258    fn test_sync_ocm_state_preserves_per_bet_fill_cursors_after_replace() {
8259        let trader_id = TraderId::from("TESTER-001");
8260        let strategy_id = StrategyId::from("S-001");
8261        let instrument_id = InstrumentId::from("1.234567-12345-0.0.BETFAIR");
8262        let client_order_id = ClientOrderId::from("O-SYNC-REPLACE");
8263        let account_id = AccountId::from("BETFAIR-001");
8264        let old_bet_id = VenueOrderId::from("old-bet");
8265        let new_bet_id = VenueOrderId::from("new-bet");
8266        let mut order = OrderTestBuilder::new(OrderType::Limit)
8267            .trader_id(trader_id)
8268            .strategy_id(strategy_id)
8269            .instrument_id(instrument_id)
8270            .client_order_id(client_order_id)
8271            .quantity(Quantity::from(10))
8272            .price(Price::from("3.0"))
8273            .build();
8274        order
8275            .apply(OrderEventAny::Submitted(OrderSubmitted::new(
8276                trader_id,
8277                strategy_id,
8278                instrument_id,
8279                client_order_id,
8280                account_id,
8281                UUID4::new(),
8282                UnixNanos::from(1),
8283                UnixNanos::from(1),
8284            )))
8285            .unwrap();
8286        order
8287            .apply(OrderEventAny::Filled(OrderFilled::new(
8288                trader_id,
8289                strategy_id,
8290                instrument_id,
8291                client_order_id,
8292                old_bet_id,
8293                account_id,
8294                TradeId::from("old-bet-2"),
8295                OrderSide::Buy,
8296                OrderType::Limit,
8297                Quantity::from(2),
8298                Price::from("3.0"),
8299                Currency::GBP(),
8300                LiquiditySide::Maker,
8301                UUID4::new(),
8302                UnixNanos::from(2),
8303                UnixNanos::from(2),
8304                false,
8305                None,
8306                None,
8307                None,
8308            )))
8309            .unwrap();
8310        order
8311            .apply(OrderEventAny::Updated(OrderUpdated::new(
8312                trader_id,
8313                strategy_id,
8314                instrument_id,
8315                client_order_id,
8316                Quantity::from(4),
8317                UUID4::new(),
8318                UnixNanos::from(3),
8319                UnixNanos::from(3),
8320                false,
8321                Some(new_bet_id),
8322                Some(account_id),
8323                Some(Price::from("4.0")),
8324                None,
8325                None,
8326                false,
8327            )))
8328            .unwrap();
8329        order
8330            .apply(OrderEventAny::Filled(OrderFilled::new(
8331                trader_id,
8332                strategy_id,
8333                instrument_id,
8334                client_order_id,
8335                new_bet_id,
8336                account_id,
8337                TradeId::from("new-bet-1"),
8338                OrderSide::Buy,
8339                OrderType::Limit,
8340                Quantity::from(1),
8341                Price::from("4.0"),
8342                Currency::GBP(),
8343                LiquiditySide::Taker,
8344                UUID4::new(),
8345                UnixNanos::from(4),
8346                UnixNanos::from(4),
8347                false,
8348                None,
8349                None,
8350                None,
8351            )))
8352            .unwrap();
8353
8354        let cache = Rc::new(RefCell::new(Cache::default()));
8355        cache
8356            .borrow_mut()
8357            .add_order(order, None, Some(ClientId::from("BETFAIR-SYNC")), false)
8358            .unwrap();
8359        let config = BetfairExecutionClientConfig::default();
8360        let core = ExecutionClientCore::new(
8361            trader_id,
8362            ClientId::from("BETFAIR-SYNC"),
8363            *BETFAIR_VENUE,
8364            OmsType::Netting,
8365            account_id,
8366            AccountType::Betting,
8367            None,
8368            cache,
8369        );
8370        let credential = BetfairCredential::new(
8371            "username".to_string(),
8372            "password".to_string(),
8373            "app-key".to_string(),
8374        );
8375        let http_client =
8376            BetfairHttpClient::new(credential.clone(), None, None, None, None, None, None).unwrap();
8377        let client = BetfairExecutionClient::new(
8378            core,
8379            http_client,
8380            credential,
8381            config.stream_config(),
8382            config,
8383            Currency::GBP(),
8384        )
8385        .unwrap();
8386
8387        client.sync_ocm_state_from_cache();
8388
8389        let mut state = client.ocm_state.lock();
8390        let old_increment = state.fill_tracker.advance_cumulative_fill(
8391            old_bet_id.as_str(),
8392            Decimal::from(3),
8393            Some(Decimal::from(3)),
8394            Decimal::from(3),
8395        );
8396        let current_replay = state.fill_tracker.advance_cumulative_fill(
8397            new_bet_id.as_str(),
8398            Decimal::ONE,
8399            Some(Decimal::from(4)),
8400            Decimal::from(4),
8401        );
8402
8403        assert_eq!(state.order_strategy_id(&client_order_id), Some(strategy_id),);
8404        assert!(!state.mark_accepted(client_order_id));
8405        assert_eq!(
8406            state.client_order_id_by_venue_order_id(old_bet_id.as_str()),
8407            Some(client_order_id),
8408        );
8409        assert_eq!(
8410            old_increment.map(|(_, quantity, price)| (quantity, price)),
8411            Some((Quantity::from(1), Price::from("3.0"))),
8412        );
8413        assert_eq!(current_replay, None);
8414    }
8415
8416    #[rstest]
8417    fn test_sync_ocm_state_closed_order_limit_counts_only_venue_identities() {
8418        let trader_id = TraderId::from("TESTER-001");
8419        let strategy_id = StrategyId::from("S-001");
8420        let instrument_id = InstrumentId::from("1.234567-12345-0.0.BETFAIR");
8421        let client_order_id = ClientOrderId::from("O-RETAINED-TERMINAL");
8422        let account_id = AccountId::from("BETFAIR-001");
8423        let venue_order_id = VenueOrderId::from("retained-terminal-bet");
8424        let client_id = ClientId::from("BETFAIR-SYNC");
8425        let mut retained = OrderTestBuilder::new(OrderType::Limit)
8426            .trader_id(trader_id)
8427            .strategy_id(strategy_id)
8428            .instrument_id(instrument_id)
8429            .client_order_id(client_order_id)
8430            .quantity(Quantity::from(10))
8431            .price(Price::from("3.0"))
8432            .build();
8433        retained
8434            .apply(OrderEventAny::Accepted(OrderAccepted::new(
8435                trader_id,
8436                strategy_id,
8437                instrument_id,
8438                client_order_id,
8439                venue_order_id,
8440                account_id,
8441                UUID4::new(),
8442                UnixNanos::from(1),
8443                UnixNanos::from(1),
8444                false,
8445            )))
8446            .unwrap();
8447        retained
8448            .apply(OrderEventAny::Canceled(OrderCanceled::new(
8449                trader_id,
8450                strategy_id,
8451                instrument_id,
8452                client_order_id,
8453                UUID4::new(),
8454                UnixNanos::from(2),
8455                UnixNanos::from(2),
8456                false,
8457                Some(venue_order_id),
8458                Some(account_id),
8459                None,
8460            )))
8461            .unwrap();
8462
8463        let mut cache = Cache::default();
8464        cache
8465            .add_order(retained, None, Some(client_id), false)
8466            .unwrap();
8467
8468        for index in 0..OcmState::DEDUP_RETENTION {
8469            let denied_client_order_id = ClientOrderId::from(format!("O-DENIED-{index}"));
8470            let mut denied = OrderTestBuilder::new(OrderType::Limit)
8471                .trader_id(trader_id)
8472                .strategy_id(strategy_id)
8473                .instrument_id(instrument_id)
8474                .client_order_id(denied_client_order_id)
8475                .quantity(Quantity::from(10))
8476                .price(Price::from("3.0"))
8477                .build();
8478            denied
8479                .apply(OrderEventAny::Denied(OrderDenied::new(
8480                    trader_id,
8481                    strategy_id,
8482                    instrument_id,
8483                    denied_client_order_id,
8484                    Ustr::from("not placed"),
8485                    UUID4::new(),
8486                    UnixNanos::from(index as u64 + 3),
8487                    UnixNanos::from(index as u64 + 3),
8488                )))
8489                .unwrap();
8490            cache
8491                .add_order(denied, None, Some(client_id), false)
8492                .unwrap();
8493        }
8494
8495        let cache = Rc::new(RefCell::new(cache));
8496        let config = BetfairExecutionClientConfig::default();
8497        let core = ExecutionClientCore::new(
8498            trader_id,
8499            client_id,
8500            *BETFAIR_VENUE,
8501            OmsType::Netting,
8502            account_id,
8503            AccountType::Betting,
8504            None,
8505            cache,
8506        );
8507        let credential = BetfairCredential::new(
8508            "username".to_string(),
8509            "password".to_string(),
8510            "app-key".to_string(),
8511        );
8512        let http_client =
8513            BetfairHttpClient::new(credential.clone(), None, None, None, None, None, None).unwrap();
8514        let client = BetfairExecutionClient::new(
8515            core,
8516            http_client,
8517            credential,
8518            config.stream_config(),
8519            config,
8520            Currency::GBP(),
8521        )
8522        .unwrap();
8523
8524        client.sync_ocm_state_from_cache();
8525
8526        let state = client.ocm_state.lock();
8527        assert_eq!(
8528            state.client_order_id_by_venue_order_id(venue_order_id.as_str()),
8529            Some(client_order_id),
8530        );
8531        assert_eq!(state.order_strategy_id(&client_order_id), Some(strategy_id));
8532        assert!(state.terminal_orders.contains(venue_order_id.as_str()));
8533        assert!(state.is_retained_terminal_order(&client_order_id));
8534    }
8535
8536    #[rstest]
8537    fn test_sync_cached_fills_restores_terminal_void_cursor() {
8538        let trader_id = TraderId::from("TESTER-001");
8539        let strategy_id = StrategyId::from("S-001");
8540        let instrument_id = InstrumentId::from("1.234567-12345-0.0.BETFAIR");
8541        let client_order_id = ClientOrderId::from("O-SYNC-VOID");
8542        let account_id = AccountId::from("BETFAIR-001");
8543        let venue_order_id = VenueOrderId::from("voided-bet");
8544        let mut order = OrderTestBuilder::new(OrderType::Limit)
8545            .trader_id(trader_id)
8546            .strategy_id(strategy_id)
8547            .instrument_id(instrument_id)
8548            .client_order_id(client_order_id)
8549            .quantity(Quantity::from(10))
8550            .price(Price::from("3.0"))
8551            .build();
8552        order
8553            .apply(OrderEventAny::Accepted(OrderAccepted::new(
8554                trader_id,
8555                strategy_id,
8556                instrument_id,
8557                client_order_id,
8558                venue_order_id,
8559                account_id,
8560                UUID4::new(),
8561                UnixNanos::from(1),
8562                UnixNanos::from(1),
8563                false,
8564            )))
8565            .unwrap();
8566        order
8567            .apply(OrderEventAny::FillVoided(OrderFillVoided::new(
8568                trader_id,
8569                strategy_id,
8570                instrument_id,
8571                client_order_id,
8572                venue_order_id,
8573                account_id,
8574                Ustr::from("voided-bet-sv"),
8575                TradeId::from("VOID-voided-bet"),
8576                Quantity::from(4),
8577                None,
8578                OrderSide::Buy,
8579                OrderType::Limit,
8580                Price::from("3.0"),
8581                Currency::GBP(),
8582                LiquiditySide::NoLiquiditySide,
8583                None,
8584                None,
8585                None,
8586                UUID4::new(),
8587                UnixNanos::from(2),
8588                UnixNanos::from(2),
8589                false,
8590                false,
8591            )))
8592            .unwrap();
8593
8594        let mut state = OcmState::default();
8595        state.sync_from_orders(&[BetfairExecutionClient::order_sync_entry(&order).unwrap()]);
8596        BetfairExecutionClient::sync_cached_fills(&mut state, [&order]);
8597        let mut replay = cancel_unmatched_order(venue_order_id.as_str(), None);
8598        replay.s = Decimal::from(10);
8599        replay.sc = None;
8600        replay.sm = Some(Decimal::ZERO);
8601        replay.sv = Some(Decimal::from(4));
8602
8603        assert_eq!(order.status(), OrderStatus::Voided);
8604        assert_eq!(order.voided_qty(), Quantity::from(4));
8605        assert!(!state.fill_tracker.has_unseen_fill_void(&replay));
8606        assert!(state.fill_tracker.maybe_fill_voids(&replay).is_empty());
8607
8608        replay.sv = Some(Decimal::from(6));
8609        let state = Arc::new(Mutex::new(state));
8610        let (emitter, mut rx) = emitter_with_receiver(account_id);
8611        let processed = BetfairExecutionClient::process_unmatched_order(
8612            &replay,
8613            instrument_id,
8614            account_id,
8615            Currency::GBP(),
8616            &emitter,
8617            &state,
8618            UnixNanos::from(3),
8619            UnixNanos::from(3),
8620        );
8621        let fill_voided = match rx.try_recv().unwrap() {
8622            ExecutionEvent::Order(OrderEventAny::FillVoided(fill_voided)) => fill_voided,
8623            other => panic!("expected cache-restored direct fill void, was {other:?}"),
8624        };
8625
8626        assert!(processed);
8627        assert_eq!(fill_voided.client_order_id, client_order_id);
8628        assert_eq!(fill_voided.strategy_id, strategy_id);
8629        assert_eq!(fill_voided.venue_order_id, venue_order_id);
8630        assert_eq!(fill_voided.voided_qty, Quantity::from(6));
8631        assert!(rx.try_recv().is_err());
8632    }
8633
8634    #[rstest]
8635    fn test_reconnect_signal_not_sent_on_initial_connection() {
8636        let has_initial_connection = Arc::new(AtomicBool::new(false));
8637        let (reconnect_tx, mut reconnect_rx) = tokio::sync::mpsc::unbounded_channel::<()>();
8638
8639        let has_initial = Arc::clone(&has_initial_connection);
8640        let handler = move |_data: &[u8]| {
8641            if has_initial.swap(true, Ordering::SeqCst) {
8642                let _ = reconnect_tx.send(());
8643            }
8644        };
8645
8646        // First connection message: no signal
8647        handler(br#"{"op":"connection","connectionId":"abc"}"#);
8648        assert!(reconnect_rx.try_recv().is_err());
8649        assert!(has_initial_connection.load(Ordering::SeqCst));
8650    }
8651
8652    #[rstest]
8653    fn test_reconnect_signal_sent_on_subsequent_connection() {
8654        let has_initial_connection = Arc::new(AtomicBool::new(false));
8655        let (reconnect_tx, mut reconnect_rx) = tokio::sync::mpsc::unbounded_channel::<()>();
8656
8657        let has_initial = Arc::clone(&has_initial_connection);
8658        let tx = reconnect_tx;
8659        let handler = move |_data: &[u8]| {
8660            if has_initial.swap(true, Ordering::SeqCst) {
8661                let _ = tx.send(());
8662            }
8663        };
8664
8665        // First connection: no signal
8666        handler(br#"{"op":"connection","connectionId":"abc"}"#);
8667        assert!(reconnect_rx.try_recv().is_err());
8668
8669        // Second connection: signal sent
8670        handler(br#"{"op":"connection","connectionId":"def"}"#);
8671        assert!(reconnect_rx.try_recv().is_ok());
8672
8673        // Third connection: signal sent again
8674        handler(br#"{"op":"connection","connectionId":"ghi"}"#);
8675        assert!(reconnect_rx.try_recv().is_ok());
8676    }
8677
8678    #[rstest]
8679    fn test_reconnect_sets_reconciliation_gate() {
8680        let pending_resync = Arc::new(AtomicBool::new(false));
8681        let reconciliation_gate = Arc::new(ReconciliationGate::default());
8682        let (reconnect_tx, mut reconnect_rx) = tokio::sync::mpsc::unbounded_channel();
8683        let handler = ocm_reconnect_handler(
8684            reconnect_tx,
8685            Arc::clone(&pending_resync),
8686            Arc::clone(&reconciliation_gate),
8687        );
8688
8689        handler(stream_decode(br#"{"op":"connection","connectionId":"first"}"#).unwrap());
8690        assert!(reconnect_rx.try_recv().is_err());
8691        assert!(!pending_resync.load(Ordering::Acquire));
8692        assert!(!reconciliation_gate.is_halted());
8693
8694        handler(stream_decode(br#"{"op":"connection","connectionId":"second"}"#).unwrap());
8695        assert!(reconnect_rx.try_recv().is_err());
8696        handler(
8697            stream_decode(br#"{"op":"ocm","id":2,"pt":1000,"ct":"RESUB_DELTA","oc":[]}"#).unwrap(),
8698        );
8699        assert_eq!(reconnect_rx.try_recv().unwrap(), 1);
8700        handler(
8701            stream_decode(br#"{"op":"ocm","id":2,"pt":1001,"ct":"RESUB_DELTA","oc":[]}"#).unwrap(),
8702        );
8703        assert!(reconnect_rx.try_recv().is_err());
8704        assert!(pending_resync.load(Ordering::Acquire));
8705        assert!(reconciliation_gate.is_halted());
8706    }
8707
8708    #[rstest]
8709    fn test_first_connection_after_transport_loss_schedules_reconciliation() {
8710        let pending_resync = Arc::new(AtomicBool::new(false));
8711        let reconciliation_gate = Arc::new(ReconciliationGate::default());
8712        let (reconnect_tx, mut reconnect_rx) = tokio::sync::mpsc::unbounded_channel();
8713        let handler = ocm_reconnect_handler(
8714            reconnect_tx,
8715            Arc::clone(&pending_resync),
8716            Arc::clone(&reconciliation_gate),
8717        );
8718
8719        assert_eq!(reconciliation_gate.halt(), 1);
8720        handler(stream_decode(br#"{"op":"connection","connectionId":"replacement"}"#).unwrap());
8721        assert!(reconnect_rx.try_recv().is_err());
8722        handler(
8723            stream_decode(br#"{"op":"ocm","id":2,"pt":1000,"ct":"SUB_IMAGE","oc":[]}"#).unwrap(),
8724        );
8725
8726        assert_eq!(reconnect_rx.try_recv().unwrap(), 1);
8727        assert!(pending_resync.load(Ordering::Acquire));
8728        assert!(reconciliation_gate.is_halted());
8729    }
8730
8731    #[rstest]
8732    fn test_new_503_epoch_supersedes_in_flight_recovery() {
8733        let pending_resync = Arc::new(AtomicBool::new(false));
8734        let reconciliation_gate = Arc::new(ReconciliationGate::default());
8735        let (reconnect_tx, mut reconnect_rx) = tokio::sync::mpsc::unbounded_channel();
8736        let handler = ocm_reconnect_handler(
8737            reconnect_tx,
8738            Arc::clone(&pending_resync),
8739            Arc::clone(&reconciliation_gate),
8740        );
8741
8742        handler(
8743            stream_decode(br#"{"op":"ocm","id":2,"pt":1000,"ct":"HEARTBEAT","status":503}"#)
8744                .unwrap(),
8745        );
8746        handler(stream_decode(br#"{"op":"ocm","id":2,"pt":1001,"ct":"HEARTBEAT"}"#).unwrap());
8747        let stale = reconnect_rx.try_recv().unwrap();
8748
8749        handler(
8750            stream_decode(br#"{"op":"ocm","id":2,"pt":1002,"ct":"HEARTBEAT","status":503}"#)
8751                .unwrap(),
8752        );
8753        let current = reconciliation_gate.current_generation();
8754        handler(
8755            stream_decode(br#"{"op":"ocm","id":2,"pt":1003,"ct":"HEARTBEAT","status":503}"#)
8756                .unwrap(),
8757        );
8758
8759        assert_ne!(current, stale);
8760        assert_eq!(reconciliation_gate.current_generation(), current);
8761        assert!(!reconciliation_gate.try_resume(stale));
8762
8763        handler(stream_decode(br#"{"op":"ocm","id":2,"pt":1004,"ct":"HEARTBEAT"}"#).unwrap());
8764        assert_eq!(reconnect_rx.try_recv().unwrap(), current);
8765        assert!(pending_resync.load(Ordering::Acquire));
8766        assert!(reconciliation_gate.is_halted());
8767    }
8768
8769    fn ocm_reconnect_handler(
8770        reconnect_tx: tokio::sync::mpsc::UnboundedSender<u64>,
8771        pending_resync: Arc<AtomicBool>,
8772        reconciliation_gate: Arc<ReconciliationGate>,
8773    ) -> StreamMessageHandler {
8774        let account_id = AccountId::from("BETFAIR-001");
8775        let (emitter, _execution_rx) = emitter_with_receiver(account_id);
8776        let (data_tx, _data_rx) = tokio::sync::mpsc::unbounded_channel();
8777        let (account_refresh_tx, _account_refresh_rx) = tokio::sync::mpsc::unbounded_channel();
8778
8779        BetfairExecutionClient::create_ocm_handler(
8780            emitter,
8781            account_id,
8782            Currency::GBP(),
8783            Arc::new(Mutex::new(OcmState::default())),
8784            data_tx.into(),
8785            None,
8786            false,
8787            reconnect_tx,
8788            Arc::new(AtomicU64::new(0)),
8789            pending_resync,
8790            reconciliation_gate,
8791            Arc::new(Mutex::new(Vec::new())),
8792            account_refresh_tx,
8793            get_atomic_clock_realtime(),
8794        )
8795    }
8796
8797    #[rstest]
8798    fn test_reconciliation_gate_rejects_stale_completion() {
8799        let gate = ReconciliationGate::default();
8800
8801        let stale = gate.halt();
8802        let current = gate.halt();
8803
8804        assert!(gate.is_halted());
8805        assert!(!gate.try_resume(stale));
8806        assert!(gate.is_halted());
8807        assert!(gate.try_resume(current));
8808        assert!(!gate.is_halted());
8809    }
8810
8811    #[rstest]
8812    fn test_reconciliation_gate_publish_failure_stays_halted() {
8813        let gate = ReconciliationGate::default();
8814        let generation = gate.halt();
8815
8816        let result = gate.commit(generation, || anyhow::bail!("receiver closed"));
8817
8818        assert!(result.is_err());
8819        assert!(gate.is_halted());
8820        assert_eq!(gate.current_generation(), generation);
8821    }
8822
8823    #[rstest]
8824    #[case::unbounded(None, None, vec![0, 1, 2, 3, 4])]
8825    #[case::lower_bound(Some(1), None, vec![1, 2, 3, 4])]
8826    #[case::bounded(Some(1), Some(3), vec![1, 2, 3])]
8827    fn test_snapshot_fill_lookback_preserves_order_coverage(
8828        #[case] start: Option<usize>,
8829        #[case] end: Option<usize>,
8830        #[case] expected: Vec<usize>,
8831    ) {
8832        let dates = [
8833            "2026-09-17T10:00:00.000Z",
8834            "2026-09-17T10:00:00.001Z",
8835            "2026-09-17T10:00:00.002Z",
8836            "2026-09-17T10:00:00.003Z",
8837            "2026-09-17T10:00:00.004Z",
8838        ];
8839        let data = load_test_json("rest/list_current_orders_execution_complete.json");
8840        let response: CurrentOrderSummaryReport = parse_jsonrpc(&data);
8841        let account_id = AccountId::from("BETFAIR-001");
8842        let (emitter, _receiver) = emitter_with_receiver(account_id);
8843        let mut orders = Vec::new();
8844
8845        for (index, date) in dates.iter().enumerate() {
8846            let mut order = response.current_orders[1].clone();
8847            order.bet_id = format!("bet-{index}");
8848            order.matched_date = Some((*date).to_string());
8849            orders.push(order);
8850        }
8851
8852        let mut unmatched = response.current_orders[0].clone();
8853        unmatched.bet_id = "unmatched".to_string();
8854        orders.push(unmatched);
8855
8856        let reports = orders
8857            .iter()
8858            .map(|order| {
8859                parse_current_order_report(order, account_id, UnixNanos::default()).unwrap()
8860            })
8861            .collect();
8862
8863        let mut eligible = orders.clone();
8864        retain_snapshot_fill_orders(
8865            &mut eligible,
8866            start.map(|index| parse_betfair_timestamp(dates[index]).unwrap()),
8867            end.map(|index| parse_betfair_timestamp(dates[index]).unwrap()),
8868        )
8869        .unwrap();
8870        let mut state = OcmState::default();
8871
8872        let (snapshot, updates) = MassStatusSnapshot {
8873            client_id: ClientId::from("BETFAIR"),
8874            account_id,
8875            currency: Currency::GBP(),
8876            ts_init: UnixNanos::default(),
8877            order_reports: reports,
8878            active_quantities: AHashMap::new(),
8879            voided_quantities: AHashMap::new(),
8880            fill_orders: eligible,
8881            account_state: None,
8882        }
8883        .build(&mut state, &emitter)
8884        .unwrap();
8885
8886        assert_eq!(snapshot.order_reports().len(), orders.len());
8887        assert_eq!(snapshot.fill_reports().len(), expected.len());
8888        assert!(updates.is_empty());
8889
8890        for (index, order) in orders.iter().enumerate() {
8891            assert_eq!(
8892                state.fill_tracker.has_fill_lots(&order.bet_id),
8893                expected.contains(&index)
8894            );
8895        }
8896
8897        // A later unbounded request must still deliver every excluded increment
8898        retain_snapshot_fill_orders(&mut orders, None, None).unwrap();
8899        let fills = build_incremental_fill_reports(
8900            &orders,
8901            &mut state.fill_tracker,
8902            &state.customer_order_refs,
8903            account_id,
8904            Currency::GBP(),
8905            UnixNanos::default(),
8906        )
8907        .unwrap();
8908        let actual = fills
8909            .iter()
8910            .map(|fill| fill.venue_order_id.to_string())
8911            .collect::<Vec<_>>();
8912        let remaining = (0..dates.len())
8913            .filter(|index| !expected.contains(index))
8914            .map(|index| format!("bet-{index}"))
8915            .collect::<Vec<_>>();
8916        assert_eq!(actual, remaining);
8917    }
8918
8919    #[rstest]
8920    fn test_snapshot_voided_only_order_does_not_create_fill() {
8921        let data = load_test_json("rest/list_current_orders_execution_complete.json");
8922        let response: CurrentOrderSummaryReport = parse_jsonrpc(&data);
8923        let mut order = response.current_orders[1].clone();
8924        order.size_matched = Some(Decimal::ZERO);
8925        order.size_voided = Some(Decimal::from(10));
8926        let account_id = AccountId::from("BETFAIR-001");
8927        let (emitter, _receiver) = emitter_with_receiver(account_id);
8928        let report = parse_current_order_report(&order, account_id, UnixNanos::default()).unwrap();
8929        let mut orders = vec![order.clone()];
8930        retain_snapshot_fill_orders(&mut orders, None, None).unwrap();
8931        let mut state = OcmState::default();
8932
8933        let (snapshot, updates) = MassStatusSnapshot {
8934            client_id: ClientId::from("BETFAIR"),
8935            account_id,
8936            currency: Currency::GBP(),
8937            ts_init: UnixNanos::default(),
8938            order_reports: vec![report],
8939            active_quantities: AHashMap::new(),
8940            voided_quantities: AHashMap::new(),
8941            fill_orders: orders,
8942            account_state: None,
8943        }
8944        .build(&mut state, &emitter)
8945        .unwrap();
8946
8947        let actual = &snapshot.order_reports()[&VenueOrderId::from(order.bet_id.as_str())];
8948        assert_eq!(actual.order_status, OrderStatus::Voided);
8949        assert_eq!(actual.filled_qty, Quantity::from(0));
8950        assert!(snapshot.fill_reports().is_empty());
8951        assert!(updates.is_empty());
8952        assert!(!state.fill_tracker.has_fill_lots(&order.bet_id));
8953        let mut replay = fill_unmatched_order(&order.bet_id, None, Decimal::ZERO);
8954        replay.sv = Some(Decimal::from(10));
8955        assert!(!state.fill_tracker.has_unseen_fill_void(&replay));
8956    }
8957
8958    #[rstest]
8959    fn test_unpublished_recovery_does_not_advance_fill_tracker() {
8960        let gate = ReconciliationGate::default();
8961        let generation = gate.halt();
8962        let account_id = AccountId::from("BETFAIR-001");
8963        let (emitter, receiver) = emitter_with_receiver(account_id);
8964        drop(receiver);
8965        let ocm_state = Arc::new(Mutex::new(OcmState::default()));
8966        let data = load_test_json("rest/list_current_orders_execution_complete.json");
8967        let response: CurrentOrderSummaryReport = parse_jsonrpc(&data);
8968        let mut fill_order = response.current_orders[1].clone();
8969        fill_order.bet_id = "bet-unpublished".to_string();
8970
8971        let recovery = || MassStatusSnapshot {
8972            client_id: ClientId::from("BETFAIR"),
8973            account_id,
8974            currency: Currency::GBP(),
8975            ts_init: UnixNanos::default(),
8976            order_reports: Vec::new(),
8977            active_quantities: AHashMap::new(),
8978            voided_quantities: AHashMap::new(),
8979            fill_orders: vec![fill_order.clone()],
8980            account_state: None,
8981        };
8982
8983        let result =
8984            commit_post_reconnect_mass_status(&gate, generation, &ocm_state, &emitter, recovery());
8985
8986        assert!(result.is_err());
8987        assert!(gate.is_halted());
8988        assert!(
8989            !ocm_state
8990                .lock()
8991                .fill_tracker
8992                .has_fill_lots("bet-unpublished")
8993        );
8994        let (emitter, mut receiver) = emitter_with_receiver(account_id);
8995        let committed =
8996            commit_post_reconnect_mass_status(&gate, generation, &ocm_state, &emitter, recovery())
8997                .unwrap();
8998
8999        let published = match receiver.try_recv().unwrap() {
9000            ExecutionEvent::Report(ExecutionReport::MassStatus(status)) => status,
9001            other => panic!("expected retried mass status, was {other:?}"),
9002        };
9003
9004        let fills = published.fill_reports();
9005        let fill = &fills[&VenueOrderId::from("bet-unpublished")][0];
9006        assert_eq!(
9007            committed.map(|(orders, fills, _)| (orders, fills)),
9008            Some((0, 1))
9009        );
9010        assert_eq!(fill.last_qty, Quantity::from(10));
9011        assert_eq!(fill.trade_id, TradeId::from("bet-unpublished-10.00"));
9012        assert!(!gate.is_halted());
9013
9014        let generation = gate.halt();
9015        let repeated =
9016            commit_post_reconnect_mass_status(&gate, generation, &ocm_state, &emitter, recovery())
9017                .unwrap();
9018        assert_eq!(
9019            repeated.map(|(orders, fills, _)| (orders, fills)),
9020            Some((0, 0))
9021        );
9022    }
9023
9024    #[rstest]
9025    fn test_invalid_recovery_does_not_publish_or_advance_fill_tracker() {
9026        let gate = ReconciliationGate::default();
9027        let generation = gate.halt();
9028        let account_id = AccountId::from("BETFAIR-001");
9029        let (emitter, mut receiver) = emitter_with_receiver(account_id);
9030        let ocm_state = Arc::new(Mutex::new(OcmState::default()));
9031        let data = load_test_json("rest/list_current_orders_execution_complete.json");
9032        let response: CurrentOrderSummaryReport = parse_jsonrpc(&data);
9033        let mut fill_order = response.current_orders[1].clone();
9034        fill_order.bet_id = "bet-invalid".to_string();
9035        fill_order.placed_date = "not-a-timestamp".to_string();
9036
9037        let recovery = MassStatusSnapshot {
9038            client_id: ClientId::from("BETFAIR"),
9039            account_id,
9040            currency: Currency::GBP(),
9041            ts_init: UnixNanos::default(),
9042            order_reports: Vec::new(),
9043            active_quantities: AHashMap::new(),
9044            voided_quantities: AHashMap::new(),
9045            fill_orders: vec![fill_order],
9046            account_state: None,
9047        };
9048
9049        let result =
9050            commit_post_reconnect_mass_status(&gate, generation, &ocm_state, &emitter, recovery);
9051
9052        assert!(result.is_err());
9053        assert!(gate.is_halted());
9054        assert!(receiver.try_recv().is_err());
9055        assert!(!ocm_state.lock().fill_tracker.has_fill_lots("bet-invalid"));
9056    }
9057
9058    #[rstest]
9059    fn test_recovery_commit_uses_current_fill_tracker() {
9060        let gate = ReconciliationGate::default();
9061        let generation = gate.halt();
9062        let account_id = AccountId::from("BETFAIR-001");
9063        let (emitter, mut receiver) = emitter_with_receiver(account_id);
9064        let data = load_test_json("rest/list_current_orders_execution_complete.json");
9065        let response: CurrentOrderSummaryReport = parse_jsonrpc(&data);
9066        let fill_order = response.current_orders[1].clone();
9067        let ocm_state = Arc::new(Mutex::new(OcmState::default()));
9068        assert!(
9069            ocm_state
9070                .lock()
9071                .fill_tracker
9072                .advance_cumulative_fill(
9073                    &fill_order.bet_id,
9074                    Decimal::from(5),
9075                    fill_order.average_price_matched,
9076                    fill_order.price_size.price,
9077                )
9078                .is_some()
9079        );
9080
9081        let recovery = MassStatusSnapshot {
9082            client_id: ClientId::from("BETFAIR"),
9083            account_id,
9084            currency: Currency::GBP(),
9085            ts_init: UnixNanos::default(),
9086            order_reports: Vec::new(),
9087            active_quantities: AHashMap::new(),
9088            voided_quantities: AHashMap::new(),
9089            fill_orders: vec![fill_order.clone()],
9090            account_state: None,
9091        };
9092
9093        let committed =
9094            commit_post_reconnect_mass_status(&gate, generation, &ocm_state, &emitter, recovery)
9095                .unwrap();
9096        let mass_status = match receiver.try_recv().unwrap() {
9097            ExecutionEvent::Report(ExecutionReport::MassStatus(status)) => status,
9098            other => panic!("expected mass status, was {other:?}"),
9099        };
9100        let fills = mass_status.fill_reports();
9101        let fill = &fills[&VenueOrderId::from(fill_order.bet_id.as_str())][0];
9102
9103        assert_eq!(
9104            committed.map(|(orders, fills, _)| (orders, fills)),
9105            Some((0, 1))
9106        );
9107        assert_eq!(fill.last_qty, Quantity::from("5.00"));
9108        assert!(!gate.is_halted());
9109        assert!(
9110            ocm_state
9111                .lock()
9112                .fill_tracker
9113                .advance_cumulative_fill(
9114                    &fill_order.bet_id,
9115                    fill_order.size_matched.unwrap(),
9116                    fill_order.average_price_matched,
9117                    fill_order.price_size.price,
9118                )
9119                .is_none()
9120        );
9121    }
9122
9123    #[rstest]
9124    fn test_recovery_commit_resolves_pending_reduction() {
9125        let gate = ReconciliationGate::default();
9126        let generation = gate.halt();
9127        let account_id = AccountId::from("BETFAIR-001");
9128        let client_order_id = ClientOrderId::from("O-RECOVERY-REDUCTION");
9129        let strategy_id = StrategyId::from("S-001");
9130        let data = load_test_json("rest/list_current_orders_executable.json");
9131        let response: CurrentOrderSummaryReport = parse_jsonrpc(&data);
9132        let order = response.current_orders[0].clone();
9133        let bet_id = order.bet_id.clone();
9134        let mut report =
9135            parse_current_order_report(&order, account_id, UnixNanos::default()).unwrap();
9136        report.client_order_id = Some(client_order_id);
9137        let mut state = OcmState::default();
9138        state
9139            .register_submission(client_order_id, strategy_id)
9140            .unwrap();
9141        state.register_pending_reduction(
9142            client_order_id,
9143            bet_id.clone(),
9144            Quantity::from(10),
9145            Quantity::from(4),
9146        );
9147        let ocm_state = Arc::new(Mutex::new(state));
9148        let (emitter, mut receiver) = emitter_with_receiver(account_id);
9149
9150        let recovery = MassStatusSnapshot {
9151            client_id: ClientId::from("BETFAIR"),
9152            account_id,
9153            currency: Currency::GBP(),
9154            ts_init: UnixNanos::default(),
9155            order_reports: vec![report],
9156            active_quantities: AHashMap::from([(bet_id.clone(), Quantity::from(4))]),
9157            voided_quantities: AHashMap::new(),
9158            fill_orders: Vec::new(),
9159            account_state: None,
9160        };
9161
9162        let committed =
9163            commit_post_reconnect_mass_status(&gate, generation, &ocm_state, &emitter, recovery)
9164                .unwrap();
9165        let updated = match receiver.try_recv().unwrap() {
9166            ExecutionEvent::Order(OrderEventAny::Updated(updated)) => updated,
9167            other => panic!("expected reconciled order update, was {other:?}"),
9168        };
9169        let mass_status = match receiver.try_recv().unwrap() {
9170            ExecutionEvent::Report(ExecutionReport::MassStatus(status)) => status,
9171            other => panic!("expected mass status after order update, was {other:?}"),
9172        };
9173
9174        assert_eq!(
9175            committed.map(|(orders, fills, _)| (orders, fills)),
9176            Some((0, 0))
9177        );
9178        assert!(mass_status.order_reports().is_empty());
9179        assert_eq!(updated.client_order_id, client_order_id);
9180        assert_eq!(updated.quantity, Quantity::from(4));
9181        assert_eq!(updated.price, None);
9182        assert!(updated.reconciliation);
9183        assert_eq!(
9184            ocm_state.lock().reduced_quantity(&bet_id),
9185            Some(Quantity::from(4)),
9186        );
9187        assert!(!gate.is_halted());
9188    }
9189
9190    #[rstest]
9191    fn test_reconciliation_promotes_closed_replace_before_terminal_report() {
9192        let gate = ReconciliationGate::default();
9193        let account_id = AccountId::from("BETFAIR-001");
9194        let client_order_id = ClientOrderId::from("O-RECOVERY-REPLACE-CLOSED");
9195        let strategy_id = StrategyId::from("S-001");
9196        let old_bet_id = "old-bet";
9197        let new_bet_id = "new-bet";
9198        let mut old_order = make_summary(
9199            old_bet_id,
9200            "1.100",
9201            12345,
9202            Decimal::ZERO,
9203            BetfairOrderStatus::ExecutionComplete,
9204            "2026-08-25T00:00:00Z",
9205        );
9206        old_order.size_remaining = Some(Decimal::ZERO);
9207        old_order.size_cancelled = Some(Decimal::from(10));
9208        old_order.customer_order_ref = Some(make_customer_order_ref(client_order_id.as_str()));
9209        let mut old_report =
9210            parse_current_order_report(&old_order, account_id, UnixNanos::default()).unwrap();
9211        old_report.client_order_id = Some(client_order_id);
9212        let mut new_order = make_summary(
9213            new_bet_id,
9214            "1.100",
9215            12345,
9216            Decimal::ZERO,
9217            BetfairOrderStatus::ExecutionComplete,
9218            "2026-08-25T00:00:00Z",
9219        );
9220        new_order.size_remaining = Some(Decimal::ZERO);
9221        new_order.size_cancelled = Some(Decimal::from(10));
9222        new_order.customer_order_ref = Some(make_customer_order_ref(client_order_id.as_str()));
9223        let mut new_report =
9224            parse_current_order_report(&new_order, account_id, UnixNanos::default()).unwrap();
9225        new_report.client_order_id = Some(client_order_id);
9226        let mut state = OcmState::default();
9227        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(old_bet_id));
9228        state.register_pending_replace(
9229            client_order_id,
9230            old_bet_id.to_string(),
9231            Some(Quantity::from(10)),
9232        );
9233        state.mark_pending_replace_ambiguous(client_order_id, old_bet_id);
9234        let ocm_state = Arc::new(Mutex::new(state));
9235        let (emitter, mut receiver) = emitter_with_receiver(account_id);
9236
9237        let generation = gate.halt();
9238        let first = commit_post_reconnect_mass_status(
9239            &gate,
9240            generation,
9241            &ocm_state,
9242            &emitter,
9243            MassStatusSnapshot {
9244                client_id: ClientId::from("BETFAIR"),
9245                account_id,
9246                currency: Currency::GBP(),
9247                ts_init: UnixNanos::default(),
9248                order_reports: vec![old_report.clone(), new_report.clone()],
9249                active_quantities: AHashMap::new(),
9250                voided_quantities: AHashMap::new(),
9251                fill_orders: Vec::new(),
9252                account_state: None,
9253            },
9254        )
9255        .unwrap();
9256        let updated = match receiver.try_recv().unwrap() {
9257            ExecutionEvent::Order(OrderEventAny::Updated(updated)) => updated,
9258            other => panic!("expected replacement update before terminal report, was {other:?}"),
9259        };
9260        let first_mass_status = match receiver.try_recv().unwrap() {
9261            ExecutionEvent::Report(ExecutionReport::MassStatus(status)) => status,
9262            other => {
9263                panic!("expected terminal mass status after replacement update, was {other:?}")
9264            }
9265        };
9266
9267        let generation = gate.halt();
9268        let repeated = commit_post_reconnect_mass_status(
9269            &gate,
9270            generation,
9271            &ocm_state,
9272            &emitter,
9273            MassStatusSnapshot {
9274                client_id: ClientId::from("BETFAIR"),
9275                account_id,
9276                currency: Currency::GBP(),
9277                ts_init: UnixNanos::default(),
9278                order_reports: vec![old_report, new_report],
9279                active_quantities: AHashMap::new(),
9280                voided_quantities: AHashMap::new(),
9281                fill_orders: Vec::new(),
9282                account_state: None,
9283            },
9284        )
9285        .unwrap();
9286        let repeated_mass_status = match receiver.try_recv().unwrap() {
9287            ExecutionEvent::Report(ExecutionReport::MassStatus(status)) => status,
9288            other => panic!("closed replacement must not emit a second update, was {other:?}"),
9289        };
9290        let state = ocm_state.lock();
9291
9292        assert_eq!(
9293            first.map(|(orders, fills, _)| (orders, fills)),
9294            Some((1, 0))
9295        );
9296        assert_eq!(updated.client_order_id, client_order_id);
9297        assert_eq!(updated.strategy_id, strategy_id);
9298        assert_eq!(updated.venue_order_id, Some(VenueOrderId::from(new_bet_id)));
9299        assert_eq!(updated.quantity, Quantity::from(10));
9300        assert_eq!(updated.price, Some(Price::from("2.00")));
9301        assert!(updated.reconciliation);
9302        assert_eq!(first_mass_status.order_reports().len(), 1);
9303        let first_report = &first_mass_status.order_reports()[&VenueOrderId::from(new_bet_id)];
9304        assert_eq!(first_report.client_order_id, Some(client_order_id));
9305        assert_eq!(first_report.order_status, OrderStatus::Canceled);
9306        assert_eq!(first_report.quantity, Quantity::from(10));
9307        assert_eq!(
9308            repeated.map(|(orders, fills, _)| (orders, fills)),
9309            Some((2, 0))
9310        );
9311        assert_eq!(repeated_mass_status.order_reports().len(), 2);
9312        assert!(
9313            repeated_mass_status
9314                .order_reports()
9315                .contains_key(&VenueOrderId::from(old_bet_id))
9316        );
9317        assert!(
9318            repeated_mass_status
9319                .order_reports()
9320                .contains_key(&VenueOrderId::from(new_bet_id))
9321        );
9322        assert!(receiver.try_recv().is_err());
9323        assert_eq!(
9324            state.client_order_id_by_venue_order_id(old_bet_id),
9325            Some(client_order_id),
9326        );
9327        assert_eq!(
9328            state.client_order_id_by_venue_order_id(new_bet_id),
9329            Some(client_order_id),
9330        );
9331        assert!(state.is_retained_terminal_order(&client_order_id));
9332        assert!(state.replaced_venue_order_ids.contains(old_bet_id));
9333        assert!(!state.pending_replace_awaits_reconciliation(&client_order_id, old_bet_id));
9334    }
9335
9336    #[rstest]
9337    #[case::known(true, false, true)]
9338    #[case::new(false, false, false)]
9339    #[case::reregistered(true, true, false)]
9340    fn test_report_finalization_rejects_only_the_collected_replace(
9341        #[case] collected: bool,
9342        #[case] reregistered: bool,
9343        #[case] rejected: bool,
9344    ) {
9345        let account_id = AccountId::from("BETFAIR-001");
9346        let client_order_id = ClientOrderId::from("O-REPORT-REPLACE");
9347        let bet_id = "report-bet";
9348        let mut order = make_summary(
9349            bet_id,
9350            "1.100",
9351            12345,
9352            Decimal::ZERO,
9353            BetfairOrderStatus::Executable,
9354            "2026-08-25T00:00:00Z",
9355        );
9356        order.customer_order_ref = Some(make_customer_order_ref(client_order_id.as_str()));
9357        let report = parse_current_order_report(&order, account_id, UnixNanos::default()).unwrap();
9358        let mut expected_report = report.clone();
9359        expected_report.client_order_id = Some(client_order_id);
9360        let state = Arc::new(Mutex::new(OcmState::default()));
9361        {
9362            let mut state = state.lock();
9363            state.restore_order(
9364                client_order_id,
9365                StrategyId::from("S-001"),
9366                VenueOrderId::from(bet_id),
9367            );
9368            state.register_pending_replace(
9369                client_order_id,
9370                bet_id.to_string(),
9371                Some(Quantity::from(10)),
9372            );
9373            state.mark_pending_replace_ambiguous(client_order_id, bet_id);
9374        }
9375
9376        let ambiguous_replaces = if collected {
9377            state.lock().pending_replace_reconciliation_ids()
9378        } else {
9379            AHashMap::new()
9380        };
9381
9382        if reregistered {
9383            let mut state = state.lock();
9384            state.take_pending_replace(client_order_id, bet_id);
9385            state.register_pending_replace(
9386                client_order_id,
9387                bet_id.to_string(),
9388                Some(Quantity::from(10)),
9389            );
9390            state.mark_pending_replace_ambiguous(client_order_id, bet_id);
9391        }
9392
9393        let fetched = FetchedOrderStatusReports {
9394            orders: vec![order],
9395            reports: vec![report],
9396            ambiguous_replaces,
9397            ..Default::default()
9398        };
9399
9400        let (emitter, mut receiver) = emitter_with_receiver(account_id);
9401
9402        let reports = finish_order_status_reports(fetched, None, &state, Some(&emitter), true);
9403        let events: Vec<_> = std::iter::from_fn(|| receiver.try_recv().ok()).collect();
9404
9405        assert_eq!(reports, vec![expected_report.clone()]);
9406        assert_eq!(
9407            state
9408                .lock()
9409                .pending_replace_awaits_reconciliation(&client_order_id, bet_id),
9410            !rejected
9411        );
9412        assert_eq!(events.len(), usize::from(rejected));
9413
9414        if rejected {
9415            let ExecutionEvent::Order(OrderEventAny::ModifyRejected(event)) = &events[0] else {
9416                panic!("expected modification rejection, was {:?}", events[0]);
9417            };
9418
9419            assert_eq!(
9420                *event,
9421                OrderModifyRejected::new(
9422                    emitter.trader_id(),
9423                    StrategyId::from("S-001"),
9424                    expected_report.instrument_id,
9425                    client_order_id,
9426                    Ustr::from("Original bet remained executable after ambiguous replace"),
9427                    event.event_id,
9428                    expected_report.ts_last,
9429                    expected_report.ts_init,
9430                    true,
9431                    Some(VenueOrderId::from(bet_id)),
9432                    Some(account_id),
9433                )
9434            );
9435        }
9436    }
9437
9438    #[rstest]
9439    fn test_report_owners_use_current_reference_resolution() {
9440        let account_id = AccountId::from("BETFAIR-001");
9441        let client_order_id = ClientOrderId::from("O-REPORT-OWNER");
9442        let mut order = make_summary(
9443            "owner-bet",
9444            "1.100",
9445            12345,
9446            Decimal::ZERO,
9447            BetfairOrderStatus::Executable,
9448            "2026-08-25T00:00:00Z",
9449        );
9450        let reference = make_customer_order_ref(client_order_id.as_str());
9451        order.customer_order_ref = Some(reference.clone());
9452        let report = parse_current_order_report(&order, account_id, UnixNanos::default()).unwrap();
9453        let mut expected_report = report.clone();
9454        expected_report.client_order_id = None;
9455        let mut state = OcmState::default();
9456        state
9457            .customer_order_refs
9458            .insert(reference, CustomerOrderRefResolution::Ambiguous);
9459        let mut reports = vec![report];
9460
9461        assign_report_owners(&mut reports, &state);
9462
9463        assert_eq!(reports, vec![expected_report]);
9464    }
9465
9466    #[rstest]
9467    fn test_fill_finalization_uses_current_tracker_atomically() {
9468        let account_id = AccountId::from("BETFAIR-001");
9469        let currency = Currency::GBP();
9470        let mut order = make_summary(
9471            "fill-bet",
9472            "1.100",
9473            12345,
9474            Decimal::ZERO,
9475            BetfairOrderStatus::Executable,
9476            "2026-08-25T00:00:00Z",
9477        );
9478        order.size_matched = Some(Decimal::from(7));
9479        order.average_price_matched = Some(Decimal::from(3));
9480        let state = Arc::new(Mutex::new(OcmState::default()));
9481        state.lock().fill_tracker.advance_cumulative_fill(
9482            "fill-bet",
9483            Decimal::from(4),
9484            Some(Decimal::from(3)),
9485            Decimal::from(3),
9486        );
9487
9488        let mut invalid_order = order.clone();
9489        invalid_order.bet_id = "fill-invalid".to_string();
9490        invalid_order.placed_date = "invalid-date".to_string();
9491        let failed = finish_fill_reports(
9492            &[order.clone(), invalid_order],
9493            &state,
9494            account_id,
9495            currency,
9496            UnixNanos::default(),
9497        )
9498        .unwrap_err();
9499
9500        let reports = finish_fill_reports(
9501            &[order.clone()],
9502            &state,
9503            account_id,
9504            currency,
9505            UnixNanos::default(),
9506        )
9507        .unwrap();
9508        let repeated =
9509            finish_fill_reports(&[order], &state, account_id, currency, UnixNanos::default())
9510                .unwrap();
9511
9512        assert_eq!(
9513            failed.to_string(),
9514            format!(
9515                "Failed to parse fill report for fill-invalid: {}",
9516                parse_betfair_timestamp("invalid-date").unwrap_err(),
9517            )
9518        );
9519        assert_eq!(reports.len(), 1);
9520        assert_eq!(
9521            reports[0],
9522            FillReport::new(
9523                account_id,
9524                InstrumentId::from("1.100-12345.BETFAIR"),
9525                VenueOrderId::from("fill-bet"),
9526                TradeId::from("fill-bet-7.00"),
9527                OrderSide::Sell,
9528                Quantity::from("3.00"),
9529                Price::from("3.00"),
9530                Money::zero(currency),
9531                LiquiditySide::NoLiquiditySide,
9532                None,
9533                None,
9534                parse_betfair_timestamp("2026-08-25T00:00:00Z").unwrap(),
9535                UnixNanos::default(),
9536                Some(reports[0].report_id),
9537            )
9538        );
9539        assert!(repeated.is_empty());
9540    }
9541
9542    #[rstest]
9543    fn test_reconciliation_resolves_unique_closed_replace_without_new_bet() {
9544        let account_id = AccountId::from("BETFAIR-001");
9545        let client_order_id = ClientOrderId::from("O-RECOVERY-REPLACE-CANCELED");
9546        let strategy_id = StrategyId::from("S-001");
9547        let old_bet_id = "old-bet";
9548        let mut order = make_summary(
9549            old_bet_id,
9550            "1.100",
9551            12345,
9552            Decimal::ZERO,
9553            BetfairOrderStatus::ExecutionComplete,
9554            "2026-08-25T00:00:00Z",
9555        );
9556        order.size_remaining = Some(Decimal::ZERO);
9557        order.size_cancelled = Some(Decimal::from(10));
9558        let mut report =
9559            parse_current_order_report(&order, account_id, UnixNanos::default()).unwrap();
9560        report.client_order_id = Some(client_order_id);
9561        let mut reports = vec![report];
9562        let mut state = OcmState::default();
9563        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(old_bet_id));
9564        state.register_pending_replace(
9565            client_order_id,
9566            old_bet_id.to_string(),
9567            Some(Quantity::from(10)),
9568        );
9569        state.mark_pending_replace_ambiguous(client_order_id, old_bet_id);
9570        let (emitter, _receiver) = emitter_with_receiver(account_id);
9571
9572        let updates = resolve_pending_modifies_in_state(
9573            &mut reports,
9574            &AHashMap::new(),
9575            &AHashMap::new(),
9576            &mut state,
9577            &emitter,
9578            None,
9579        );
9580
9581        assert!(updates.is_empty());
9582        assert_eq!(reports.len(), 1);
9583        assert_eq!(reports[0].client_order_id, Some(client_order_id));
9584        assert_eq!(reports[0].venue_order_id, VenueOrderId::from(old_bet_id));
9585        assert_eq!(reports[0].order_status, OrderStatus::Canceled);
9586        assert!(!state.pending_replace_awaits_reconciliation(&client_order_id, old_bet_id));
9587        assert!(state.is_retained_terminal_order(&client_order_id));
9588    }
9589
9590    #[rstest]
9591    fn test_reconciliation_folds_replaced_leg_fills_into_successor() {
9592        let account_id = AccountId::from("BETFAIR-001");
9593        let client_order_id = ClientOrderId::from("O-REPLACED-FILLS");
9594        let strategy_id = StrategyId::from("S-001");
9595        let old_bet_id = "old-bet";
9596        let new_bet_id = "new-bet";
9597        let mut old_order = make_summary(
9598            old_bet_id,
9599            "1.100",
9600            12345,
9601            Decimal::ZERO,
9602            BetfairOrderStatus::ExecutionComplete,
9603            "2026-08-25T00:00:00Z",
9604        );
9605        old_order.size_matched = Some(Decimal::from(4));
9606        old_order.size_remaining = Some(Decimal::ZERO);
9607        old_order.size_cancelled = Some(Decimal::from(6));
9608        old_order.average_price_matched = Some(Decimal::from(3));
9609        let mut old_report =
9610            parse_current_order_report(&old_order, account_id, UnixNanos::default()).unwrap();
9611        old_report.client_order_id = Some(client_order_id);
9612        let mut new_order = make_summary(
9613            new_bet_id,
9614            "1.100",
9615            12345,
9616            Decimal::ZERO,
9617            BetfairOrderStatus::Executable,
9618            "2026-08-25T00:01:00Z",
9619        );
9620        new_order.price_size.size = Decimal::from(6);
9621        new_order.size_matched = Some(Decimal::from(2));
9622        new_order.size_remaining = Some(Decimal::from(4));
9623        new_order.average_price_matched = Some(Decimal::from(5));
9624        let mut new_report =
9625            parse_current_order_report(&new_order, account_id, UnixNanos::default()).unwrap();
9626        new_report.client_order_id = Some(client_order_id);
9627        let mut reports = vec![old_report, new_report];
9628        let mut state = OcmState::default();
9629        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(new_bet_id));
9630        state
9631            .replaced_venue_order_ids
9632            .insert(old_bet_id.to_string());
9633        let (emitter, _receiver) = emitter_with_receiver(account_id);
9634
9635        let updates = resolve_pending_modifies_in_state(
9636            &mut reports,
9637            &AHashMap::new(),
9638            &AHashMap::new(),
9639            &mut state,
9640            &emitter,
9641            None,
9642        );
9643
9644        assert!(updates.is_empty());
9645        assert_eq!(reports.len(), 1);
9646        let successor = reports
9647            .iter()
9648            .find(|report| report.venue_order_id == VenueOrderId::from(new_bet_id))
9649            .unwrap();
9650        assert_eq!(successor.order_status, OrderStatus::PartiallyFilled);
9651        assert_eq!(successor.quantity, Quantity::from("10"));
9652        assert_eq!(successor.filled_qty, Quantity::from("6"));
9653        assert_eq!(successor.avg_px, Some(Decimal::from(22) / Decimal::from(6)));
9654    }
9655
9656    #[rstest]
9657    fn test_reconciliation_fills_across_repeated_replacements() {
9658        let account_id = AccountId::from("BETFAIR-001");
9659        let client_order_id = ClientOrderId::from("O-REPEATED-REPLACEMENTS");
9660        let strategy_id = StrategyId::from("S-001");
9661        let first_bet_id = "first-bet";
9662        let second_bet_id = "second-bet";
9663        let third_bet_id = "third-bet";
9664        let mut first_order = make_summary(
9665            first_bet_id,
9666            "1.100",
9667            12345,
9668            Decimal::ZERO,
9669            BetfairOrderStatus::ExecutionComplete,
9670            "2026-08-25T00:00:00Z",
9671        );
9672        first_order.size_matched = Some(Decimal::from(1));
9673        first_order.size_remaining = Some(Decimal::ZERO);
9674        first_order.size_cancelled = Some(Decimal::from(9));
9675        first_order.average_price_matched = Some(Decimal::from(2));
9676        let mut second_order = make_summary(
9677            second_bet_id,
9678            "1.100",
9679            12345,
9680            Decimal::ZERO,
9681            BetfairOrderStatus::ExecutionComplete,
9682            "2026-08-25T00:01:00Z",
9683        );
9684        second_order.price_size.size = Decimal::from(9);
9685        second_order.size_matched = Some(Decimal::from(2));
9686        second_order.size_remaining = Some(Decimal::ZERO);
9687        second_order.size_cancelled = Some(Decimal::from(7));
9688        second_order.average_price_matched = Some(Decimal::from(3));
9689        let mut third_order = make_summary(
9690            third_bet_id,
9691            "1.100",
9692            12345,
9693            Decimal::ZERO,
9694            BetfairOrderStatus::Executable,
9695            "2026-08-25T00:02:00Z",
9696        );
9697        third_order.price_size.size = Decimal::from(7);
9698        third_order.size_matched = Some(Decimal::from(3));
9699        third_order.size_remaining = Some(Decimal::from(4));
9700        third_order.average_price_matched = Some(Decimal::from(4));
9701        let mut reports = Vec::new();
9702
9703        for order in [&first_order, &second_order, &third_order] {
9704            let mut report =
9705                parse_current_order_report(order, account_id, UnixNanos::default()).unwrap();
9706            report.client_order_id = Some(client_order_id);
9707            reports.push(report);
9708        }
9709
9710        let mut state = OcmState::default();
9711        state.restore_order(
9712            client_order_id,
9713            strategy_id,
9714            VenueOrderId::from(third_bet_id),
9715        );
9716        state
9717            .replaced_venue_order_ids
9718            .insert(first_bet_id.to_string());
9719        state
9720            .replaced_venue_order_ids
9721            .insert(second_bet_id.to_string());
9722        let (emitter, _receiver) = emitter_with_receiver(account_id);
9723
9724        let updates = resolve_pending_modifies_in_state(
9725            &mut reports,
9726            &AHashMap::new(),
9727            &AHashMap::new(),
9728            &mut state,
9729            &emitter,
9730            None,
9731        );
9732
9733        assert!(updates.is_empty());
9734        let successor = reports
9735            .iter()
9736            .find(|report| report.venue_order_id == VenueOrderId::from(third_bet_id))
9737            .unwrap();
9738        assert_eq!(successor.quantity, Quantity::from("10"));
9739        assert_eq!(successor.filled_qty, Quantity::from("6"));
9740        assert_eq!(successor.avg_px, Some(Decimal::from(20) / Decimal::from(6)));
9741    }
9742
9743    #[rstest]
9744    fn test_reconciliation_folds_fills_into_terminal_successor() {
9745        let account_id = AccountId::from("BETFAIR-001");
9746        let client_order_id = ClientOrderId::from("O-TERMINAL-SUCCESSOR");
9747        let strategy_id = StrategyId::from("S-001");
9748        let old_bet_id = "old-bet";
9749        let new_bet_id = "new-bet";
9750        let mut old_order = make_summary(
9751            old_bet_id,
9752            "1.100",
9753            12345,
9754            Decimal::ZERO,
9755            BetfairOrderStatus::ExecutionComplete,
9756            "2026-08-25T00:00:00Z",
9757        );
9758        old_order.size_matched = Some(Decimal::from(4));
9759        old_order.size_remaining = Some(Decimal::ZERO);
9760        old_order.size_cancelled = Some(Decimal::from(6));
9761        old_order.average_price_matched = Some(Decimal::from(3));
9762        let mut new_order = make_summary(
9763            new_bet_id,
9764            "1.100",
9765            12345,
9766            Decimal::ZERO,
9767            BetfairOrderStatus::ExecutionComplete,
9768            "2026-08-25T00:01:00Z",
9769        );
9770        new_order.price_size.size = Decimal::from(6);
9771        new_order.size_matched = Some(Decimal::from(6));
9772        new_order.size_remaining = Some(Decimal::ZERO);
9773        new_order.average_price_matched = Some(Decimal::from(5));
9774        let mut reports = Vec::new();
9775
9776        for order in [&old_order, &new_order] {
9777            let mut report =
9778                parse_current_order_report(order, account_id, UnixNanos::default()).unwrap();
9779            report.client_order_id = Some(client_order_id);
9780            reports.push(report);
9781        }
9782
9783        let mut state = OcmState::default();
9784        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(new_bet_id));
9785        state
9786            .replaced_venue_order_ids
9787            .insert(old_bet_id.to_string());
9788        let (emitter, _receiver) = emitter_with_receiver(account_id);
9789
9790        let updates = resolve_pending_modifies_in_state(
9791            &mut reports,
9792            &AHashMap::new(),
9793            &AHashMap::new(),
9794            &mut state,
9795            &emitter,
9796            None,
9797        );
9798
9799        assert!(updates.is_empty());
9800        // The retained terminal identity keeps the predecessor leg in the mass
9801        // status; the engine short-circuits it as a superseded cancel.
9802        assert_eq!(reports.len(), 2);
9803        let successor = reports
9804            .iter()
9805            .find(|report| report.venue_order_id == VenueOrderId::from(new_bet_id))
9806            .unwrap();
9807        assert_eq!(successor.order_status, OrderStatus::Filled);
9808        assert_eq!(successor.quantity, Quantity::from("10"));
9809        assert_eq!(successor.filled_qty, Quantity::from("10"));
9810        assert_eq!(
9811            successor.avg_px,
9812            Some(Decimal::from(42) / Decimal::from(10))
9813        );
9814    }
9815
9816    #[rstest]
9817    fn test_replace_fold_includes_replaced_leg_voided_quantity() {
9818        let account_id = AccountId::from("BETFAIR-001");
9819        let client_order_id = ClientOrderId::from("O-REPLACE-VOIDED-LEG");
9820        let strategy_id = StrategyId::from("S-001");
9821        let old_bet_id = "old-bet";
9822        let new_bet_id = "new-bet";
9823        // Original size 10: 4 matched, 2 non-reopened voided, 4 still cancelled/unfilled
9824        let mut old_order = make_summary(
9825            old_bet_id,
9826            "1.100",
9827            12345,
9828            Decimal::ZERO,
9829            BetfairOrderStatus::ExecutionComplete,
9830            "2026-08-25T00:00:00Z",
9831        );
9832        old_order.size_matched = Some(Decimal::from(4));
9833        old_order.size_voided = Some(Decimal::from(2));
9834        old_order.size_remaining = Some(Decimal::ZERO);
9835        old_order.size_cancelled = Some(Decimal::from(4));
9836        // Betfair re-places the replacement bet for exactly the pre-replace remaining size
9837        // (10 - 4 matched - 2 voided = 4), not the original total.
9838        let mut new_order = make_summary(
9839            new_bet_id,
9840            "1.100",
9841            12345,
9842            Decimal::ZERO,
9843            BetfairOrderStatus::Executable,
9844            "2026-08-25T00:01:00Z",
9845        );
9846        new_order.price_size.size = Decimal::from(4);
9847        new_order.size_matched = Some(Decimal::ZERO);
9848        new_order.size_remaining = Some(Decimal::from(4));
9849        let mut reports = Vec::new();
9850
9851        for order in [&old_order, &new_order] {
9852            let mut report =
9853                parse_current_order_report(order, account_id, UnixNanos::default()).unwrap();
9854            report.client_order_id = Some(client_order_id);
9855            reports.push(report);
9856        }
9857
9858        let mut state = OcmState::default();
9859        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(new_bet_id));
9860        state
9861            .replaced_venue_order_ids
9862            .insert(old_bet_id.to_string());
9863        let (emitter, _receiver) = emitter_with_receiver(account_id);
9864
9865        resolve_pending_modifies_in_state(
9866            &mut reports,
9867            &AHashMap::new(),
9868            &AHashMap::from([(old_bet_id.to_string(), Quantity::from(2))]),
9869            &mut state,
9870            &emitter,
9871            None,
9872        );
9873
9874        let successor = reports
9875            .iter()
9876            .find(|report| report.venue_order_id == VenueOrderId::from(new_bet_id))
9877            .unwrap();
9878        // 4 (new leg's own placed size) + 4 (old leg matched) + 2 (old leg voided)
9879        assert_eq!(successor.quantity, Quantity::from("10"));
9880        assert_eq!(successor.filled_qty, Quantity::from("4"));
9881    }
9882
9883    #[rstest]
9884    fn test_replace_fold_of_voided_only_leg_keeps_successor_accepted() {
9885        let account_id = AccountId::from("BETFAIR-001");
9886        let client_order_id = ClientOrderId::from("O-REPLACE-VOIDED-ONLY-LEG");
9887        let strategy_id = StrategyId::from("S-001");
9888        let old_bet_id = "old-bet";
9889        let new_bet_id = "new-bet";
9890        let mut old_order = make_summary(
9891            old_bet_id,
9892            "1.100",
9893            12345,
9894            Decimal::ZERO,
9895            BetfairOrderStatus::ExecutionComplete,
9896            "2026-08-25T00:00:00Z",
9897        );
9898        old_order.size_matched = Some(Decimal::ZERO);
9899        old_order.size_voided = Some(Decimal::from(2));
9900        old_order.size_remaining = Some(Decimal::ZERO);
9901        old_order.size_cancelled = Some(Decimal::from(8));
9902        let mut new_order = make_summary(
9903            new_bet_id,
9904            "1.100",
9905            12345,
9906            Decimal::ZERO,
9907            BetfairOrderStatus::Executable,
9908            "2026-08-25T00:01:00Z",
9909        );
9910        new_order.price_size.size = Decimal::from(8);
9911        new_order.size_matched = Some(Decimal::ZERO);
9912        new_order.size_remaining = Some(Decimal::from(8));
9913        let mut reports = Vec::new();
9914
9915        for order in [&old_order, &new_order] {
9916            let mut report =
9917                parse_current_order_report(order, account_id, UnixNanos::default()).unwrap();
9918            report.client_order_id = Some(client_order_id);
9919            reports.push(report);
9920        }
9921
9922        let mut state = OcmState::default();
9923        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(new_bet_id));
9924        state
9925            .replaced_venue_order_ids
9926            .insert(old_bet_id.to_string());
9927        let (emitter, _receiver) = emitter_with_receiver(account_id);
9928
9929        resolve_pending_modifies_in_state(
9930            &mut reports,
9931            &AHashMap::new(),
9932            &AHashMap::from([(old_bet_id.to_string(), Quantity::from(2))]),
9933            &mut state,
9934            &emitter,
9935            None,
9936        );
9937
9938        let successor = reports
9939            .iter()
9940            .find(|report| report.venue_order_id == VenueOrderId::from(new_bet_id))
9941            .unwrap();
9942        assert_eq!(successor.order_status, OrderStatus::Accepted);
9943        assert_eq!(successor.quantity, Quantity::from("10"));
9944        assert_eq!(successor.filled_qty, Quantity::from("0"));
9945        assert_eq!(successor.avg_px, None);
9946    }
9947
9948    #[rstest]
9949    fn test_reconciliation_promotion_folds_replaced_leg_voided_quantity() {
9950        let account_id = AccountId::from("BETFAIR-001");
9951        let client_order_id = ClientOrderId::from("O-PROMOTED-VOIDED-LEG");
9952        let strategy_id = StrategyId::from("S-001");
9953        let old_bet_id = "old-bet";
9954        let new_bet_id = "new-bet";
9955        // Original size 10: the old bet matched 4 and had 2 voided before the replace
9956        let mut old_order = make_summary(
9957            old_bet_id,
9958            "1.100",
9959            12345,
9960            Decimal::ZERO,
9961            BetfairOrderStatus::ExecutionComplete,
9962            "2026-08-25T00:00:00Z",
9963        );
9964        old_order.size_matched = Some(Decimal::from(4));
9965        old_order.size_voided = Some(Decimal::from(2));
9966        old_order.size_remaining = Some(Decimal::ZERO);
9967        old_order.size_cancelled = Some(Decimal::from(4));
9968        let mut new_order = make_summary(
9969            new_bet_id,
9970            "1.100",
9971            12345,
9972            Decimal::ZERO,
9973            BetfairOrderStatus::ExecutionComplete,
9974            "2026-08-25T00:01:00Z",
9975        );
9976        new_order.price_size.size = Decimal::from(4);
9977        new_order.size_matched = Some(Decimal::ZERO);
9978        new_order.size_remaining = Some(Decimal::ZERO);
9979        new_order.size_cancelled = Some(Decimal::from(4));
9980        let mut reports = Vec::new();
9981
9982        for order in [&old_order, &new_order] {
9983            let mut report =
9984                parse_current_order_report(order, account_id, UnixNanos::default()).unwrap();
9985            report.client_order_id = Some(client_order_id);
9986            reports.push(report);
9987        }
9988
9989        // The replace is still pending, so this pass is what marks the old bet replaced
9990        let mut state = OcmState::default();
9991        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(old_bet_id));
9992        state.register_pending_replace(
9993            client_order_id,
9994            old_bet_id.to_string(),
9995            Some(Quantity::from(10)),
9996        );
9997        let (emitter, _receiver) = emitter_with_receiver(account_id);
9998
9999        let updates = resolve_pending_modifies_in_state(
10000            &mut reports,
10001            &AHashMap::new(),
10002            &AHashMap::from([(old_bet_id.to_string(), Quantity::from(2))]),
10003            &mut state,
10004            &emitter,
10005            None,
10006        );
10007
10008        let [OrderEventAny::Updated(updated)] = updates.as_slice() else {
10009            panic!("expected one OrderUpdated, was {updates:?}");
10010        };
10011
10012        assert_eq!(updated.venue_order_id, Some(VenueOrderId::from(new_bet_id)));
10013        assert_eq!(updated.quantity, Quantity::from("10"));
10014        assert!(state.replaced_venue_order_ids.contains(old_bet_id));
10015        let [successor] = reports.as_slice() else {
10016            panic!("expected the successor's report only, was {reports:?}");
10017        };
10018
10019        // 4 (successor's own size) + 4 (old bet matched) + 2 (old bet voided)
10020        assert_eq!(successor.venue_order_id, VenueOrderId::from(new_bet_id));
10021        assert_eq!(successor.quantity, Quantity::from("10"));
10022        assert_eq!(successor.filled_qty, Quantity::from("4"));
10023        assert_eq!(successor.order_status, OrderStatus::Canceled);
10024    }
10025
10026    #[rstest]
10027    #[case::executable_successor(
10028        BetfairOrderStatus::Executable,
10029        1,
10030        1,
10031        OrderStatus::PartiallyFilled
10032    )]
10033    #[case::closed_successor(BetfairOrderStatus::ExecutionComplete, 0, 2, OrderStatus::Canceled)]
10034    fn test_ambiguous_replace_resolution_keeps_replaced_leg_voided_fold(
10035        #[case] successor_status: BetfairOrderStatus,
10036        #[case] expected_rejections: usize,
10037        #[case] expected_reports: usize,
10038        #[case] expected_status: OrderStatus,
10039    ) {
10040        let account_id = AccountId::from("BETFAIR-001");
10041        let client_order_id = ClientOrderId::from("O-AMBIGUOUS-AFTER-VOIDED-LEG");
10042        let strategy_id = StrategyId::from("S-001");
10043        let old_bet_id = "old-bet";
10044        let new_bet_id = "new-bet";
10045        // Original size 10: the replaced leg matched 4 and had 2 voided
10046        let mut old_order = make_summary(
10047            old_bet_id,
10048            "1.100",
10049            12345,
10050            Decimal::ZERO,
10051            BetfairOrderStatus::ExecutionComplete,
10052            "2026-08-25T00:00:00Z",
10053        );
10054        old_order.size_matched = Some(Decimal::from(4));
10055        old_order.size_voided = Some(Decimal::from(2));
10056        old_order.size_remaining = Some(Decimal::ZERO);
10057        old_order.size_cancelled = Some(Decimal::from(4));
10058        let mut new_order = make_summary(
10059            new_bet_id,
10060            "1.100",
10061            12345,
10062            Decimal::ZERO,
10063            successor_status,
10064            "2026-08-25T00:01:00Z",
10065        );
10066        new_order.price_size.size = Decimal::from(4);
10067        new_order.size_matched = Some(Decimal::ZERO);
10068
10069        if successor_status == BetfairOrderStatus::Executable {
10070            new_order.size_remaining = Some(Decimal::from(4));
10071        } else {
10072            new_order.size_remaining = Some(Decimal::ZERO);
10073            new_order.size_cancelled = Some(Decimal::from(4));
10074        }
10075
10076        let mut reports = Vec::new();
10077
10078        for order in [&old_order, &new_order] {
10079            let mut report =
10080                parse_current_order_report(order, account_id, UnixNanos::default()).unwrap();
10081            report.client_order_id = Some(client_order_id);
10082            reports.push(report);
10083        }
10084
10085        // A second replace of the successor went ambiguous, and no further bet is listed
10086        let mut state = OcmState::default();
10087        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(new_bet_id));
10088        state
10089            .replaced_venue_order_ids
10090            .insert(old_bet_id.to_string());
10091        state.register_pending_replace(
10092            client_order_id,
10093            new_bet_id.to_string(),
10094            Some(Quantity::from(10)),
10095        );
10096        state.mark_pending_replace_ambiguous(client_order_id, new_bet_id);
10097        let (emitter, _receiver) = emitter_with_receiver(account_id);
10098
10099        let updates = resolve_pending_modifies_in_state(
10100            &mut reports,
10101            &AHashMap::new(),
10102            &AHashMap::from([(old_bet_id.to_string(), Quantity::from(2))]),
10103            &mut state,
10104            &emitter,
10105            None,
10106        );
10107
10108        let rejections = updates
10109            .iter()
10110            .filter(|update| matches!(update, OrderEventAny::ModifyRejected(_)))
10111            .count();
10112        assert_eq!(updates.len(), expected_rejections);
10113        assert_eq!(rejections, expected_rejections);
10114        assert!(!state.pending_replace_awaits_reconciliation(&client_order_id, new_bet_id));
10115        assert_eq!(reports.len(), expected_reports);
10116        let successor = reports
10117            .iter()
10118            .find(|report| report.venue_order_id == VenueOrderId::from(new_bet_id))
10119            .unwrap();
10120        // 4 (successor's own size) + 4 (replaced leg matched) + 2 (replaced leg voided)
10121        assert_eq!(successor.quantity, Quantity::from("10"));
10122        assert_eq!(successor.filled_qty, Quantity::from("4"));
10123        assert_eq!(successor.order_status, expected_status);
10124    }
10125
10126    #[rstest]
10127    fn test_reconciliation_reduction_includes_replaced_leg_voided_quantity() {
10128        let account_id = AccountId::from("BETFAIR-001");
10129        let client_order_id = ClientOrderId::from("O-REDUCED-VOIDED-REPLACEMENT");
10130        let strategy_id = StrategyId::from("S-001");
10131        let old_bet_id = "old-bet";
10132        let new_bet_id = "new-bet";
10133        let mut old_order = make_summary(
10134            old_bet_id,
10135            "1.100",
10136            12345,
10137            Decimal::ZERO,
10138            BetfairOrderStatus::ExecutionComplete,
10139            "2026-08-25T00:00:00Z",
10140        );
10141        old_order.size_matched = Some(Decimal::from(4));
10142        old_order.size_remaining = Some(Decimal::ZERO);
10143        old_order.size_voided = Some(Decimal::from(2));
10144        old_order.size_cancelled = Some(Decimal::from(4));
10145        let mut new_order = make_summary(
10146            new_bet_id,
10147            "1.100",
10148            12345,
10149            Decimal::ZERO,
10150            BetfairOrderStatus::Executable,
10151            "2026-08-25T00:01:00Z",
10152        );
10153        new_order.price_size.size = Decimal::from(4);
10154        new_order.size_matched = Some(Decimal::ZERO);
10155        new_order.size_remaining = Some(Decimal::from(4));
10156        let mut reports = Vec::new();
10157
10158        for order in [&old_order, &new_order] {
10159            let mut report =
10160                parse_current_order_report(order, account_id, UnixNanos::default()).unwrap();
10161            report.client_order_id = Some(client_order_id);
10162            reports.push(report);
10163        }
10164
10165        let mut state = OcmState::default();
10166        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(new_bet_id));
10167        state
10168            .replaced_venue_order_ids
10169            .insert(old_bet_id.to_string());
10170        // original(11) sits just above the computed active quantity (10 = 4 new-leg active + 4
10171        // old-leg matched + 2 old-leg voided), clearing the `< original` confirmation boundary
10172        // without the wide, order-data-disconnected margin a much larger original would give.
10173        state.register_pending_reduction(
10174            client_order_id,
10175            new_bet_id.to_string(),
10176            Quantity::from(11),
10177            Quantity::from(8),
10178        );
10179
10180        let (emitter, _receiver) = emitter_with_receiver(account_id);
10181
10182        let updates = resolve_pending_modifies_in_state(
10183            &mut reports,
10184            &AHashMap::from([(new_bet_id.to_string(), Quantity::from(4))]),
10185            &AHashMap::from([(old_bet_id.to_string(), Quantity::from(2))]),
10186            &mut state,
10187            &emitter,
10188            None,
10189        );
10190
10191        // 4 (new leg's own active) + 4 (old leg's matched) + 2 (old leg's voided) = 10, not the
10192        // 8 it would be without the replaced-leg voided quantity.
10193        assert_eq!(state.reduced_quantity(new_bet_id), Some(Quantity::from(10)));
10194        assert_eq!(updates.len(), 1);
10195
10196        let OrderEventAny::Updated(updated) = &updates[0] else {
10197            panic!("expected reduction update");
10198        };
10199        assert_eq!(updated.quantity, Quantity::from(10));
10200        assert_eq!(updated.client_order_id, client_order_id);
10201        assert_eq!(updated.venue_order_id, Some(VenueOrderId::from(new_bet_id)));
10202    }
10203
10204    #[rstest]
10205    #[case::confirmed(true)]
10206    #[case::pending(false)]
10207    fn test_reconciliation_preserves_confirmed_reduction_across_replacement(
10208        #[case] confirmed: bool,
10209    ) {
10210        let account_id = AccountId::from("BETFAIR-001");
10211        let client_order_id = ClientOrderId::from("O-REDUCED-REPLACEMENT");
10212        let strategy_id = StrategyId::from("S-001");
10213        let old_bet_id = "old-bet";
10214        let new_bet_id = "new-bet";
10215        let mut old_order = make_summary(
10216            old_bet_id,
10217            "1.100",
10218            12345,
10219            Decimal::ZERO,
10220            BetfairOrderStatus::ExecutionComplete,
10221            "2026-08-25T00:00:00Z",
10222        );
10223        old_order.size_matched = Some(Decimal::from(4));
10224        old_order.size_remaining = Some(Decimal::ZERO);
10225        old_order.size_cancelled = Some(Decimal::from(6));
10226        old_order.average_price_matched = Some(Decimal::from(3));
10227        let mut new_order = make_summary(
10228            new_bet_id,
10229            "1.100",
10230            12345,
10231            Decimal::ZERO,
10232            BetfairOrderStatus::Executable,
10233            "2026-08-25T00:01:00Z",
10234        );
10235        new_order.price_size.size = Decimal::from(4);
10236        new_order.size_matched = Some(Decimal::ZERO);
10237        new_order.size_remaining = Some(Decimal::from(4));
10238        let mut reports = Vec::new();
10239
10240        for order in [&old_order, &new_order] {
10241            let mut report =
10242                parse_current_order_report(order, account_id, UnixNanos::default()).unwrap();
10243            report.client_order_id = Some(client_order_id);
10244            reports.push(report);
10245        }
10246
10247        let mut state = OcmState::default();
10248        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(new_bet_id));
10249        state
10250            .replaced_venue_order_ids
10251            .insert(old_bet_id.to_string());
10252        state.register_pending_reduction(
10253            client_order_id,
10254            new_bet_id.to_string(),
10255            Quantity::from(10),
10256            Quantity::from(8),
10257        );
10258
10259        if confirmed {
10260            assert!(state.complete_pending_reduction(
10261                &client_order_id,
10262                new_bet_id,
10263                Quantity::from(8)
10264            ));
10265        }
10266
10267        let (emitter, _receiver) = emitter_with_receiver(account_id);
10268
10269        let updates = resolve_pending_modifies_in_state(
10270            &mut reports,
10271            &AHashMap::from([(new_bet_id.to_string(), Quantity::from(4))]),
10272            &AHashMap::new(),
10273            &mut state,
10274            &emitter,
10275            None,
10276        );
10277
10278        assert_eq!(state.reduced_quantity(new_bet_id), Some(Quantity::from(8)));
10279
10280        if !confirmed {
10281            assert_eq!(updates.len(), 1);
10282
10283            let OrderEventAny::Updated(updated) = &updates[0] else {
10284                panic!("expected reduction update");
10285            };
10286
10287            assert_eq!(updated.quantity, Quantity::from(8));
10288            assert_eq!(updated.client_order_id, client_order_id);
10289            assert_eq!(updated.venue_order_id, Some(VenueOrderId::from(new_bet_id)));
10290            return;
10291        }
10292
10293        assert!(updates.is_empty());
10294        let successor = reports
10295            .iter()
10296            .find(|report| report.venue_order_id == VenueOrderId::from(new_bet_id))
10297            .unwrap();
10298        assert_eq!(successor.quantity, Quantity::from("8"));
10299        assert_eq!(successor.filled_qty, Quantity::from("4"));
10300        assert_eq!(successor.avg_px, Some(Decimal::from(3)));
10301    }
10302
10303    #[rstest]
10304    #[case::confirmed(3, Some(8))]
10305    #[case::racing_fill(4, Some(9))]
10306    #[case::unchanged(5, None)]
10307    fn test_stream_reduction_after_replacement(#[case] active: i64, #[case] expected: Option<i64>) {
10308        let client_order_id = ClientOrderId::from("O-1");
10309        let strategy_id = StrategyId::from("S-001");
10310        let mut state = OcmState::default();
10311        state.restore_order(client_order_id, strategy_id, VenueOrderId::from("old-bet"));
10312        state.register_pending_replace(
10313            client_order_id,
10314            "old-bet".to_string(),
10315            Some(Quantity::from(10)),
10316        );
10317        state
10318            .complete_pending_replace(client_order_id, "old-bet", VenueOrderId::from("new-bet"))
10319            .unwrap();
10320        state
10321            .fill_tracker
10322            .sync_order("old-bet", Decimal::from(5), Decimal::from(3));
10323        state.fill_tracker.sync_voided_qty("old-bet", Decimal::ONE);
10324        state.register_pending_reduction(
10325            client_order_id,
10326            "new-bet".to_string(),
10327            Quantity::from(10),
10328            Quantity::from(8),
10329        );
10330        let fixture: serde_json::Value =
10331            serde_json::from_str(&load_test_json("stream/ocm_harness_partial_fill.json")).unwrap();
10332        let mut order: UnmatchedOrder =
10333            serde_json::from_value(fixture["oc"][0]["orc"][0]["uo"][0].clone()).unwrap();
10334        order.id = "new-bet".to_string();
10335        order.sm = Some(Decimal::ZERO);
10336        order.sr = Some(Decimal::from(active));
10337
10338        let result = BetfairExecutionClient::resolve_pending_reduction_from_stream(
10339            &mut state,
10340            Some((client_order_id, strategy_id)),
10341            &order,
10342        );
10343        let repeated = BetfairExecutionClient::resolve_pending_reduction_from_stream(
10344            &mut state,
10345            Some((client_order_id, strategy_id)),
10346            &order,
10347        );
10348
10349        let expected_quantity =
10350            expected.map(|quantity| parse_betfair_quantity(Decimal::from(quantity)).unwrap());
10351        assert_eq!(
10352            result,
10353            expected_quantity.map(|quantity| (client_order_id, strategy_id, quantity))
10354        );
10355        assert_eq!(state.reduced_quantity("new-bet"), expected_quantity);
10356        assert_eq!(repeated, None);
10357    }
10358
10359    #[rstest]
10360    fn test_query_replaced_leg_folds_skip_ambiguous_owner() {
10361        let suffix = "12345678901234567890123456789012";
10362        let first = ClientOrderId::from(format!("FIRST-{suffix}"));
10363        let second = ClientOrderId::from(format!("SECOND-{suffix}"));
10364        let mut state = OcmState::default();
10365        state.restore_order(
10366            first,
10367            StrategyId::from("S-FIRST"),
10368            VenueOrderId::from("old-bet"),
10369        );
10370        state.restore_order(
10371            second,
10372            StrategyId::from("S-SECOND"),
10373            VenueOrderId::from("new-bet"),
10374        );
10375        state.replaced_venue_order_ids.insert("old-bet".to_string());
10376        let mut old_order = make_summary(
10377            "old-bet",
10378            "1.100",
10379            12345,
10380            Decimal::ZERO,
10381            BetfairOrderStatus::ExecutionComplete,
10382            "2026-08-25T00:00:00Z",
10383        );
10384        old_order.size_matched = Some(Decimal::from(4));
10385        old_order.size_remaining = Some(Decimal::ZERO);
10386        old_order.size_cancelled = Some(Decimal::from(6));
10387        old_order.customer_order_ref = Some(suffix.to_string());
10388        let mut new_order = make_summary(
10389            "new-bet",
10390            "1.100",
10391            12345,
10392            Decimal::ZERO,
10393            BetfairOrderStatus::Executable,
10394            "2026-08-25T00:01:00Z",
10395        );
10396        new_order.size_remaining = Some(Decimal::from(4));
10397        new_order.customer_order_ref = Some(suffix.to_string());
10398        let candidates = vec![old_order, new_order];
10399
10400        let fills = replaced_leg_fills_from_candidates(&candidates, &candidates[1], &state);
10401
10402        assert!(fills.matched.is_zero());
10403    }
10404
10405    #[rstest]
10406    fn test_replaced_leg_fills_unknown_average_degrades_to_none() {
10407        let account_id = AccountId::from("BETFAIR-001");
10408        let mut successor_order = make_summary(
10409            "new-bet",
10410            "1.100",
10411            12345,
10412            Decimal::ZERO,
10413            BetfairOrderStatus::Executable,
10414            "2026-08-25T00:01:00Z",
10415        );
10416        successor_order.price_size.size = Decimal::from(2);
10417        successor_order.size_matched = Some(Decimal::from(2));
10418        successor_order.size_remaining = Some(Decimal::ZERO);
10419        successor_order.average_price_matched = Some(Decimal::from(5));
10420        let mut report =
10421            parse_current_order_report(&successor_order, account_id, UnixNanos::default()).unwrap();
10422
10423        let mut fills = ReplacedLegFills::default();
10424        fills.accumulate(Quantity::from("4"), None);
10425        fills.fold(&mut report, false);
10426
10427        assert_eq!(report.quantity, Quantity::from("6"));
10428        assert_eq!(report.filled_qty, Quantity::from("6"));
10429        assert_eq!(report.avg_px, None);
10430    }
10431
10432    #[rstest]
10433    fn test_query_replaced_leg_folds_keep_confirmed_reduction_quantity() {
10434        let account_id = AccountId::from("BETFAIR-001");
10435        let client_order_id = ClientOrderId::from("O-QUERY-REDUCED-REPLACEMENT");
10436        let strategy_id = StrategyId::from("S-001");
10437        let old_bet_id = "old-bet";
10438        let new_bet_id = "new-bet";
10439        let mut state = OcmState::default();
10440        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(new_bet_id));
10441        state
10442            .replaced_venue_order_ids
10443            .insert(old_bet_id.to_string());
10444        state.register_pending_reduction(
10445            client_order_id,
10446            new_bet_id.to_string(),
10447            Quantity::from(10),
10448            Quantity::from(8),
10449        );
10450        assert!(state.complete_pending_reduction(&client_order_id, new_bet_id, Quantity::from(8)));
10451
10452        let mut old_order = make_summary(
10453            old_bet_id,
10454            "1.100",
10455            12345,
10456            Decimal::ZERO,
10457            BetfairOrderStatus::ExecutionComplete,
10458            "2026-08-25T00:00:00Z",
10459        );
10460        old_order.size_matched = Some(Decimal::from(4));
10461        old_order.size_remaining = Some(Decimal::ZERO);
10462        old_order.size_cancelled = Some(Decimal::from(6));
10463        old_order.average_price_matched = Some(Decimal::from(3));
10464        old_order.customer_order_ref = Some(make_customer_order_ref(client_order_id.as_str()));
10465        // The venue can keep the successor's original placed size after a reduction.
10466        let mut new_order = make_summary(
10467            new_bet_id,
10468            "1.100",
10469            12345,
10470            Decimal::ZERO,
10471            BetfairOrderStatus::Executable,
10472            "2026-08-25T00:01:00Z",
10473        );
10474        new_order.price_size.size = Decimal::from(6);
10475        new_order.size_remaining = Some(Decimal::from(4));
10476        new_order.customer_order_ref = Some(make_customer_order_ref(client_order_id.as_str()));
10477        let candidates = vec![old_order, new_order.clone()];
10478        let mut report =
10479            parse_current_order_report(&new_order, account_id, UnixNanos::default()).unwrap();
10480
10481        let fills = replaced_leg_fills_from_candidates(&candidates, &candidates[1], &state);
10482        assert!(!fills.matched.is_zero());
10483        let reduced_quantity = state.reduced_quantity(&new_order.bet_id);
10484        if !fills.matched.is_zero()
10485            && let Some(quantity) = reduced_quantity
10486        {
10487            report.quantity = quantity;
10488        }
10489
10490        fills.fold(&mut report, reduced_quantity.is_some());
10491
10492        assert_eq!(report.quantity, Quantity::from("8"));
10493        assert_eq!(report.filled_qty, Quantity::from("4"));
10494        assert_eq!(report.order_status, OrderStatus::PartiallyFilled);
10495    }
10496
10497    #[rstest]
10498    fn test_query_replaced_leg_folds_include_voided_quantity() {
10499        let account_id = AccountId::from("BETFAIR-001");
10500        let client_order_id = ClientOrderId::from("O-QUERY-VOIDED-REPLACEMENT");
10501        let strategy_id = StrategyId::from("S-001");
10502        let old_bet_id = "old-bet";
10503        let new_bet_id = "new-bet";
10504        let mut state = OcmState::default();
10505        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(new_bet_id));
10506        state
10507            .replaced_venue_order_ids
10508            .insert(old_bet_id.to_string());
10509
10510        // Original size 10: the replaced leg matched 4 and had 2 voided
10511        let mut old_order = make_summary(
10512            old_bet_id,
10513            "1.100",
10514            12345,
10515            Decimal::ZERO,
10516            BetfairOrderStatus::ExecutionComplete,
10517            "2026-08-25T00:00:00Z",
10518        );
10519        old_order.size_matched = Some(Decimal::from(4));
10520        old_order.size_voided = Some(Decimal::from(2));
10521        old_order.size_remaining = Some(Decimal::ZERO);
10522        old_order.size_cancelled = Some(Decimal::from(4));
10523        old_order.customer_order_ref = Some(make_customer_order_ref(client_order_id.as_str()));
10524        let mut new_order = make_summary(
10525            new_bet_id,
10526            "1.100",
10527            12345,
10528            Decimal::ZERO,
10529            BetfairOrderStatus::Executable,
10530            "2026-08-25T00:01:00Z",
10531        );
10532        new_order.price_size.size = Decimal::from(4);
10533        new_order.size_remaining = Some(Decimal::from(4));
10534        new_order.customer_order_ref = Some(make_customer_order_ref(client_order_id.as_str()));
10535        let candidates = vec![old_order, new_order.clone()];
10536        let mut report =
10537            parse_current_order_report(&new_order, account_id, UnixNanos::default()).unwrap();
10538
10539        let fills = replaced_leg_fills_from_candidates(&candidates, &candidates[1], &state);
10540        assert_eq!(fills.matched, Quantity::from("4"));
10541        assert_eq!(fills.voided, Quantity::from("2"));
10542
10543        fills.fold(&mut report, false);
10544
10545        assert_eq!(report.quantity, Quantity::from("10"));
10546        assert_eq!(report.filled_qty, Quantity::from("4"));
10547        assert_eq!(report.order_status, OrderStatus::PartiallyFilled);
10548    }
10549
10550    #[rstest]
10551    fn test_replaced_leg_fills_promote_accepted_to_partially_filled() {
10552        let account_id = AccountId::from("BETFAIR-001");
10553        let client_order_id = ClientOrderId::from("O-RECOVERY-PRIOR-FILLS");
10554        let strategy_id = StrategyId::from("S-001");
10555        let old_bet_id = "old-bet";
10556        let new_bet_id = "new-bet";
10557        let mut old_order = make_summary(
10558            old_bet_id,
10559            "1.100",
10560            12345,
10561            Decimal::ZERO,
10562            BetfairOrderStatus::ExecutionComplete,
10563            "2026-08-25T00:00:00Z",
10564        );
10565        old_order.size_matched = Some(Decimal::from(4));
10566        old_order.size_remaining = Some(Decimal::ZERO);
10567        old_order.size_cancelled = Some(Decimal::from(6));
10568        old_order.average_price_matched = Some(Decimal::from(3));
10569        let mut new_order = make_summary(
10570            new_bet_id,
10571            "1.100",
10572            12345,
10573            Decimal::ZERO,
10574            BetfairOrderStatus::Executable,
10575            "2026-08-25T00:01:00Z",
10576        );
10577        new_order.price_size.size = Decimal::from(6);
10578        new_order.size_matched = Some(Decimal::ZERO);
10579        new_order.size_remaining = Some(Decimal::from(6));
10580        let mut reports = Vec::new();
10581
10582        for order in [&old_order, &new_order] {
10583            let mut report =
10584                parse_current_order_report(order, account_id, UnixNanos::default()).unwrap();
10585            report.client_order_id = Some(client_order_id);
10586            reports.push(report);
10587        }
10588
10589        let mut state = OcmState::default();
10590        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(new_bet_id));
10591        state
10592            .replaced_venue_order_ids
10593            .insert(old_bet_id.to_string());
10594        let (emitter, _receiver) = emitter_with_receiver(account_id);
10595
10596        let updates = resolve_pending_modifies_in_state(
10597            &mut reports,
10598            &AHashMap::new(),
10599            &AHashMap::new(),
10600            &mut state,
10601            &emitter,
10602            None,
10603        );
10604
10605        assert!(updates.is_empty());
10606        let successor = reports
10607            .iter()
10608            .find(|report| report.venue_order_id == VenueOrderId::from(new_bet_id))
10609            .unwrap();
10610        assert_eq!(successor.order_status, OrderStatus::PartiallyFilled);
10611        assert_eq!(successor.quantity, Quantity::from("10"));
10612        assert_eq!(successor.filled_qty, Quantity::from("4"));
10613        assert_eq!(successor.avg_px, Some(Decimal::from(3)));
10614    }
10615
10616    #[rstest]
10617    fn test_reconciliation_promotes_replace_folding_prior_fills() {
10618        let account_id = AccountId::from("BETFAIR-001");
10619        let client_order_id = ClientOrderId::from("O-PROMOTED-REPLACE-FILLS");
10620        let strategy_id = StrategyId::from("S-001");
10621        let old_bet_id = "old-bet";
10622        let new_bet_id = "new-bet";
10623        let mut old_order = make_summary(
10624            old_bet_id,
10625            "1.100",
10626            12345,
10627            Decimal::ZERO,
10628            BetfairOrderStatus::ExecutionComplete,
10629            "2026-08-25T00:00:00Z",
10630        );
10631        old_order.size_matched = Some(Decimal::from(4));
10632        old_order.size_remaining = Some(Decimal::ZERO);
10633        old_order.size_cancelled = Some(Decimal::from(6));
10634        old_order.average_price_matched = Some(Decimal::from(3));
10635        let mut new_order = make_summary(
10636            new_bet_id,
10637            "1.100",
10638            12345,
10639            Decimal::ZERO,
10640            BetfairOrderStatus::ExecutionComplete,
10641            "2026-08-25T00:01:00Z",
10642        );
10643        new_order.price_size.size = Decimal::from(6);
10644        new_order.size_matched = Some(Decimal::from(6));
10645        new_order.size_remaining = Some(Decimal::ZERO);
10646        new_order.average_price_matched = Some(Decimal::from(5));
10647        let mut reports = Vec::new();
10648
10649        for order in [&old_order, &new_order] {
10650            let mut report =
10651                parse_current_order_report(order, account_id, UnixNanos::default()).unwrap();
10652            report.client_order_id = Some(client_order_id);
10653            reports.push(report);
10654        }
10655
10656        let mut state = OcmState::default();
10657        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(old_bet_id));
10658        state.register_pending_replace(
10659            client_order_id,
10660            old_bet_id.to_string(),
10661            Some(Quantity::from(10)),
10662        );
10663        let (emitter, _receiver) = emitter_with_receiver(account_id);
10664
10665        let updates = resolve_pending_modifies_in_state(
10666            &mut reports,
10667            &AHashMap::new(),
10668            &AHashMap::new(),
10669            &mut state,
10670            &emitter,
10671            None,
10672        );
10673
10674        assert_eq!(updates.len(), 1);
10675
10676        match updates.into_iter().next().unwrap() {
10677            OrderEventAny::Updated(updated) => {
10678                assert_eq!(updated.client_order_id, client_order_id);
10679                assert_eq!(updated.venue_order_id, Some(VenueOrderId::from(new_bet_id)));
10680                assert_eq!(updated.quantity, Quantity::from("10"));
10681                assert!(updated.reconciliation);
10682            }
10683            other => panic!("expected replacement update, was {other:?}"),
10684        }
10685
10686        assert_eq!(reports.len(), 1);
10687        let successor = &reports[0];
10688        assert_eq!(successor.venue_order_id, VenueOrderId::from(new_bet_id));
10689        assert_eq!(successor.order_status, OrderStatus::Filled);
10690        assert_eq!(successor.quantity, Quantity::from("10"));
10691        assert_eq!(successor.filled_qty, Quantity::from("10"));
10692        assert_eq!(
10693            successor.avg_px,
10694            Some(Decimal::from(42) / Decimal::from(10))
10695        );
10696    }
10697
10698    #[rstest]
10699    fn test_reconciliation_keeps_terminal_report_after_reduction_confirmation() {
10700        let account_id = AccountId::from("BETFAIR-001");
10701        let client_order_id = ClientOrderId::from("O-RECOVERY-REDUCTION-CLOSED");
10702        let strategy_id = StrategyId::from("S-001");
10703        let bet_id = "reduced-bet";
10704        let mut order = make_summary(
10705            bet_id,
10706            "1.100",
10707            12345,
10708            Decimal::ZERO,
10709            BetfairOrderStatus::ExecutionComplete,
10710            "2026-08-25T00:00:00Z",
10711        );
10712        order.size_matched = Some(Decimal::from(4));
10713        order.size_remaining = Some(Decimal::ZERO);
10714        order.size_cancelled = Some(Decimal::from(6));
10715        order.average_price_matched = Some(Decimal::from(2));
10716        let mut report =
10717            parse_current_order_report(&order, account_id, UnixNanos::default()).unwrap();
10718        report.client_order_id = Some(client_order_id);
10719        let mut reports = vec![report];
10720        let mut state = OcmState::default();
10721        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(bet_id));
10722        state.register_pending_reduction(
10723            client_order_id,
10724            bet_id.to_string(),
10725            Quantity::from(10),
10726            Quantity::from(4),
10727        );
10728        let active_quantities = AHashMap::from([(bet_id.to_string(), Quantity::from(4))]);
10729        let (emitter, _receiver) = emitter_with_receiver(account_id);
10730
10731        let updates = resolve_pending_modifies_in_state(
10732            &mut reports,
10733            &active_quantities,
10734            &AHashMap::new(),
10735            &mut state,
10736            &emitter,
10737            None,
10738        );
10739
10740        assert!(updates.is_empty());
10741        assert_eq!(reports.len(), 1);
10742        assert_eq!(reports[0].client_order_id, Some(client_order_id));
10743        assert_eq!(reports[0].venue_order_id, VenueOrderId::from(bet_id));
10744        assert_eq!(reports[0].order_status, OrderStatus::Canceled);
10745        assert_eq!(reports[0].quantity, Quantity::from(4));
10746        assert_eq!(state.reduced_quantity(bet_id), Some(Quantity::from(4)));
10747        assert!(state.is_retained_terminal_order(&client_order_id));
10748    }
10749
10750    #[rstest]
10751    fn test_terminal_reconciliation_discards_non_actionable_reduction() {
10752        let account_id = AccountId::from("BETFAIR-001");
10753        let client_order_id = ClientOrderId::from("O-RECOVERY-REDUCTION-LAPSED");
10754        let strategy_id = StrategyId::from("S-001");
10755        let bet_id = "lapsed-bet";
10756        let mut order = make_summary(
10757            bet_id,
10758            "1.100",
10759            12345,
10760            Decimal::ZERO,
10761            BetfairOrderStatus::ExecutionComplete,
10762            "2026-08-25T00:00:00Z",
10763        );
10764        order.size_matched = Some(Decimal::from(2));
10765        order.size_remaining = Some(Decimal::ZERO);
10766        order.size_cancelled = Some(Decimal::from(8));
10767        order.average_price_matched = Some(Decimal::from(2));
10768        let mut report =
10769            parse_current_order_report(&order, account_id, UnixNanos::default()).unwrap();
10770        report.client_order_id = Some(client_order_id);
10771        let mut reports = vec![report];
10772        let mut state = OcmState::default();
10773        state.restore_order(client_order_id, strategy_id, VenueOrderId::from(bet_id));
10774        state.register_pending_reduction(
10775            client_order_id,
10776            bet_id.to_string(),
10777            Quantity::from(10),
10778            Quantity::from(4),
10779        );
10780        let active_quantities = AHashMap::from([(bet_id.to_string(), Quantity::from(2))]);
10781        let (emitter, _receiver) = emitter_with_receiver(account_id);
10782
10783        let updates = resolve_pending_modifies_in_state(
10784            &mut reports,
10785            &active_quantities,
10786            &AHashMap::new(),
10787            &mut state,
10788            &emitter,
10789            None,
10790        );
10791        let late_rest =
10792            state.complete_pending_reduction(&client_order_id, bet_id, Quantity::from(4));
10793
10794        assert!(updates.is_empty());
10795        assert_eq!(reports.len(), 1);
10796        assert_eq!(reports[0].client_order_id, Some(client_order_id));
10797        assert_eq!(reports[0].venue_order_id, VenueOrderId::from(bet_id));
10798        assert_eq!(reports[0].order_status, OrderStatus::Canceled);
10799        assert_eq!(reports[0].quantity, Quantity::from(10));
10800        assert_eq!(state.reduced_quantity(bet_id), None);
10801        assert!(state.is_retained_terminal_order(&client_order_id));
10802        assert!(!late_rest);
10803    }
10804
10805    #[rstest]
10806    fn test_reconciliation_gate_stale_commit_does_not_publish() {
10807        let gate = ReconciliationGate::default();
10808        let stale = gate.halt();
10809        let current = gate.halt();
10810        let published = AtomicBool::new(false);
10811
10812        let committed = gate
10813            .commit(stale, || {
10814                published.store(true, Ordering::Release);
10815                Ok(())
10816            })
10817            .unwrap();
10818
10819        assert!(!committed);
10820        assert!(!published.load(Ordering::Acquire));
10821        assert_eq!(gate.current_generation(), current);
10822    }
10823
10824    #[rstest]
10825    fn test_ocm_state_persists_across_reconnections() {
10826        let ocm_state = Arc::new(Mutex::new(OcmState::default()));
10827
10828        // Populate state before "reconnect"
10829        {
10830            let mut state = ocm_state.lock();
10831            let orders = vec![
10832                OrderSyncEntry {
10833                    bet_id: "bet1".to_string(),
10834                    venue_order_ids: vec!["bet1".to_string()],
10835                    client_order_id: ClientOrderId::from("O-001"),
10836                    strategy_id: StrategyId::from("S-001"),
10837                    filled_qty: Decimal::new(10, 0),
10838                    avg_px: Decimal::new(25, 1),
10839                    is_closed: false,
10840                    trade_ids: Vec::new(),
10841                },
10842                OrderSyncEntry {
10843                    bet_id: "bet2".to_string(),
10844                    venue_order_ids: vec!["bet2".to_string()],
10845                    client_order_id: ClientOrderId::from("O-002"),
10846                    strategy_id: StrategyId::from("S-001"),
10847                    filled_qty: Decimal::ZERO,
10848                    avg_px: Decimal::ZERO,
10849                    is_closed: true,
10850                    trade_ids: Vec::new(),
10851                },
10852            ];
10853            state.sync_from_orders(&orders);
10854        }
10855
10856        // Verify state survives (simulates reconnection where Arc<Mutex<OcmState>> persists)
10857        let state = ocm_state.lock();
10858        let rfo = make_customer_order_ref("O-001");
10859        assert_eq!(
10860            state.resolve_client_order_id(Some(&rfo)),
10861            Some(ClientOrderId::from("O-001")),
10862        );
10863        assert!(state.terminal_orders.contains("bet2"));
10864        assert!(!state.terminal_orders.contains("bet1"));
10865    }
10866
10867    #[rstest]
10868    fn test_ocm_state_sync_from_orders_populates_fill_tracker() {
10869        let mut state = OcmState::default();
10870
10871        let orders = vec![OrderSyncEntry {
10872            bet_id: "bet_fill".to_string(),
10873            venue_order_ids: vec!["bet_fill".to_string()],
10874            client_order_id: ClientOrderId::from("O-FILL-001"),
10875            strategy_id: StrategyId::from("S-001"),
10876            filled_qty: Decimal::new(15, 0),
10877            avg_px: Decimal::new(30, 1),
10878            is_closed: false,
10879            trade_ids: Vec::new(),
10880        }];
10881
10882        state.sync_from_orders(&orders);
10883
10884        // Fill tracker should be pre-populated so that a stream update with
10885        // sm=15 does NOT produce a duplicate fill
10886        let uo = crate::stream::messages::UnmatchedOrder {
10887            id: "bet_fill".to_string(),
10888            p: Decimal::new(30, 1),
10889            s: Decimal::new(20, 0),
10890            side: crate::common::enums::StreamingSide::Back,
10891            status: crate::common::enums::StreamingOrderStatus::Executable,
10892            pt: Some(crate::common::enums::StreamingPersistenceType::Lapse),
10893            ot: crate::common::enums::StreamingOrderType::Limit,
10894            pd: 1617863365000,
10895            bsp: None,
10896            rfo: Some("O-FILL-001".to_string()),
10897            rfs: None,
10898            rc: None,
10899            rac: None,
10900            md: None,
10901            cd: None,
10902            ld: None,
10903            avp: Some(Decimal::new(30, 1)),
10904            sm: Some(Decimal::new(15, 0)),
10905            sr: None,
10906            sl: None,
10907            sc: None,
10908            sv: None,
10909            lsrc: None,
10910        };
10911
10912        let instrument_id = InstrumentId::from("1.234567-12345-0.0.BETFAIR");
10913        let result = state.fill_tracker.maybe_fill_report(
10914            &uo,
10915            uo.s,
10916            instrument_id,
10917            AccountId::from("BETFAIR-001"),
10918            Currency::from("GBP"),
10919            UnixNanos::default(),
10920            UnixNanos::default(),
10921        );
10922
10923        assert!(
10924            result.is_none(),
10925            "synced fill should prevent duplicate fill report"
10926        );
10927    }
10928
10929    #[rstest]
10930    fn test_terminal_stream_state_prevents_rest_fill_replay() {
10931        let data = load_test_json("rest/list_current_orders_execution_complete.json");
10932        let response: CurrentOrderSummaryReport = parse_jsonrpc(&data);
10933        let mut state = OcmState::default();
10934        let account_id = AccountId::from("BETFAIR-001");
10935        let currency = Currency::GBP();
10936
10937        let mut stream_fill_count = 0;
10938
10939        for order in &response.current_orders {
10940            let size_matched = order.size_matched.unwrap_or(Decimal::ZERO);
10941
10942            if state
10943                .fill_tracker
10944                .advance_cumulative_fill(
10945                    &order.bet_id,
10946                    size_matched,
10947                    order.average_price_matched,
10948                    order.price_size.price,
10949                )
10950                .is_some()
10951            {
10952                stream_fill_count += 1;
10953            }
10954            state.mark_terminal_order(order.bet_id.clone());
10955        }
10956
10957        let customer_order_refs = state.customer_order_refs.clone();
10958        let replay = build_incremental_fill_reports(
10959            &response.current_orders,
10960            &mut state.fill_tracker,
10961            &customer_order_refs,
10962            account_id,
10963            currency,
10964            UnixNanos::default(),
10965        )
10966        .unwrap();
10967
10968        assert_eq!(stream_fill_count, 2);
10969        assert!(replay.is_empty());
10970    }
10971
10972    #[rstest]
10973    fn test_terminal_marker_without_fill_state_allows_rest_recovery() {
10974        let data = load_test_json("rest/list_current_orders_execution_complete.json");
10975        let response: CurrentOrderSummaryReport = parse_jsonrpc(&data);
10976        let mut state = OcmState::default();
10977        for order in &response.current_orders {
10978            state.mark_terminal_order(order.bet_id.clone());
10979        }
10980
10981        let customer_order_refs = state.customer_order_refs.clone();
10982        let reports = build_incremental_fill_reports(
10983            &response.current_orders,
10984            &mut state.fill_tracker,
10985            &customer_order_refs,
10986            AccountId::from("BETFAIR-001"),
10987            Currency::GBP(),
10988            UnixNanos::default(),
10989        )
10990        .unwrap();
10991
10992        assert!(!reports.is_empty());
10993    }
10994
10995    #[rstest]
10996    fn test_match_time_recovery_keeps_fill_for_order_placed_before_lookback() {
10997        let mut order = make_summary(
10998            "bet_pre_lookback",
10999            "1.100",
11000            12345,
11001            Decimal::ZERO,
11002            BetfairOrderStatus::ExecutionComplete,
11003            "2020-01-01T00:00:00Z",
11004        );
11005        order.matched_date = Some("2026-08-24T00:00:00Z".to_string());
11006        order.size_matched = Some(Decimal::new(10, 0));
11007        order.size_remaining = Some(Decimal::ZERO);
11008        order.average_price_matched = Some(Decimal::new(25, 1));
11009        let mut fill_tracker = FillTracker::default();
11010
11011        let reports = build_incremental_fill_reports(
11012            &[order],
11013            &mut fill_tracker,
11014            &AHashMap::new(),
11015            AccountId::from("BETFAIR-001"),
11016            Currency::GBP(),
11017            UnixNanos::default(),
11018        )
11019        .unwrap();
11020
11021        assert_eq!(reports.len(), 1);
11022        assert_eq!(
11023            reports[0].venue_order_id,
11024            VenueOrderId::from("bet_pre_lookback")
11025        );
11026        assert_eq!(reports[0].last_qty, Quantity::from("10.00"));
11027    }
11028
11029    #[rstest]
11030    fn test_rest_fill_omits_ambiguous_customer_order_ref() {
11031        let reference = "12345678901234567890123456789012";
11032        let first = ClientOrderId::from(format!("FIRST-{reference}"));
11033        let second = ClientOrderId::from(format!("SECOND-{reference}"));
11034        let strategy_id = StrategyId::from("S-001");
11035        let mut state = OcmState::default();
11036        state.restore_order(first, strategy_id, VenueOrderId::from("bet-first"));
11037        state.restore_order(second, strategy_id, VenueOrderId::from("bet-second"));
11038
11039        let mut order = make_summary(
11040            "bet-ambiguous",
11041            "1.100",
11042            12345,
11043            Decimal::ZERO,
11044            BetfairOrderStatus::ExecutionComplete,
11045            "2026-08-25T00:00:00Z",
11046        );
11047        order.customer_order_ref = Some(reference.to_string());
11048        order.size_matched = Some(Decimal::new(10, 0));
11049        order.size_remaining = Some(Decimal::ZERO);
11050        order.average_price_matched = Some(Decimal::new(25, 1));
11051        let customer_order_refs = state.customer_order_refs.clone();
11052
11053        let reports = build_incremental_fill_reports(
11054            &[order],
11055            &mut state.fill_tracker,
11056            &customer_order_refs,
11057            AccountId::from("BETFAIR-001"),
11058            Currency::GBP(),
11059            UnixNanos::default(),
11060        )
11061        .unwrap();
11062
11063        assert_eq!(reports.len(), 1);
11064        assert_eq!(reports[0].client_order_id, None);
11065        assert_eq!(
11066            reports[0].venue_order_id,
11067            VenueOrderId::from("bet-ambiguous"),
11068        );
11069    }
11070
11071    #[rstest]
11072    fn test_first_seen_rest_void_does_not_suppress_later_matched_quantity() {
11073        let mut order = make_summary(
11074            "bet_void_then_fill",
11075            "1.100",
11076            12345,
11077            Decimal::ZERO,
11078            BetfairOrderStatus::ExecutionComplete,
11079            "2026-04-18T10:00:00Z",
11080        );
11081        order.price_size.size = Decimal::new(60, 0);
11082        order.size_matched = Some(Decimal::ZERO);
11083        order.size_remaining = Some(Decimal::ZERO);
11084        order.size_voided = Some(Decimal::new(50, 0));
11085        let mut state = OcmState::default();
11086        let account_id = AccountId::from("BETFAIR-001");
11087
11088        let customer_order_refs = state.customer_order_refs.clone();
11089        let first = build_incremental_fill_reports(
11090            &[order.clone()],
11091            &mut state.fill_tracker,
11092            &customer_order_refs,
11093            account_id,
11094            Currency::GBP(),
11095            UnixNanos::default(),
11096        )
11097        .unwrap();
11098        order.size_matched = Some(Decimal::new(10, 0));
11099        order.average_price_matched = Some(Decimal::new(25, 1));
11100        let later = build_incremental_fill_reports(
11101            &[order],
11102            &mut state.fill_tracker,
11103            &customer_order_refs,
11104            account_id,
11105            Currency::GBP(),
11106            UnixNanos::default(),
11107        )
11108        .unwrap();
11109
11110        assert!(first.is_empty());
11111        assert_eq!(later.len(), 1);
11112        assert_eq!(later[0].last_qty, Quantity::from("10.00"));
11113        assert_eq!(later[0].last_px.as_decimal(), Decimal::new(25, 1));
11114    }
11115
11116    #[rstest]
11117    fn test_fill_report_does_not_commit_price_restatement() {
11118        let mut order = make_summary(
11119            "bet-report-restate",
11120            "1.100",
11121            12345,
11122            Decimal::ZERO,
11123            BetfairOrderStatus::ExecutionComplete,
11124            "2026-04-18T10:00:00Z",
11125        );
11126        order.price_size.size = Decimal::from(2);
11127        order.size_matched = Some(Decimal::from(2));
11128        order.size_remaining = Some(Decimal::ZERO);
11129        order.average_price_matched = Some(Decimal::from(12));
11130        let mut state = OcmState::default();
11131        let customer_order_refs = state.customer_order_refs.clone();
11132        let account_id = AccountId::from("BETFAIR-001");
11133        let first = build_incremental_fill_reports(
11134            &[order.clone()],
11135            &mut state.fill_tracker,
11136            &customer_order_refs,
11137            account_id,
11138            Currency::GBP(),
11139            UnixNanos::default(),
11140        )
11141        .unwrap();
11142        order.average_price_matched = Some(Decimal::new(947, 2));
11143        let restated = build_incremental_fill_reports(
11144            &[order],
11145            &mut state.fill_tracker,
11146            &customer_order_refs,
11147            account_id,
11148            Currency::GBP(),
11149            UnixNanos::default(),
11150        )
11151        .unwrap();
11152        let stream = state.fill_tracker.advance_cumulative_fill(
11153            "bet-report-restate",
11154            Decimal::from(2),
11155            Some(Decimal::new(947, 2)),
11156            Decimal::from(12),
11157        );
11158
11159        assert_eq!(first.len(), 1);
11160        assert!(restated.is_empty());
11161        assert_eq!(stream.unwrap().2.as_decimal(), Decimal::new(947, 2));
11162    }
11163
11164    #[rstest]
11165    fn test_rest_void_with_applied_fill_lots_remains_unseen_until_applied() {
11166        let bet_id = "bet_rest_void_pending";
11167        let mut state = OcmState::default();
11168        let initial = state.fill_tracker.advance_cumulative_fill(
11169            bet_id,
11170            Decimal::new(50, 0),
11171            Some(Decimal::new(20, 1)),
11172            Decimal::new(20, 1),
11173        );
11174        let mut order = make_summary(
11175            bet_id,
11176            "1.100",
11177            12345,
11178            Decimal::ZERO,
11179            BetfairOrderStatus::ExecutionComplete,
11180            "2026-04-18T10:00:00Z",
11181        );
11182        order.price_size.size = Decimal::new(70, 0);
11183        order.size_matched = Some(Decimal::new(50, 0));
11184        order.size_remaining = Some(Decimal::ZERO);
11185        order.size_voided = Some(Decimal::new(20, 0));
11186        order.average_price_matched = Some(Decimal::new(20, 1));
11187
11188        let customer_order_refs = state.customer_order_refs.clone();
11189        let reports = build_incremental_fill_reports(
11190            &[order],
11191            &mut state.fill_tracker,
11192            &customer_order_refs,
11193            AccountId::from("BETFAIR-001"),
11194            Currency::GBP(),
11195            UnixNanos::default(),
11196        )
11197        .unwrap();
11198        let update = crate::stream::messages::UnmatchedOrder {
11199            id: bet_id.to_string(),
11200            p: Decimal::new(20, 1),
11201            s: Decimal::new(70, 0),
11202            side: crate::common::enums::StreamingSide::Back,
11203            status: crate::common::enums::StreamingOrderStatus::ExecutionComplete,
11204            pt: Some(crate::common::enums::StreamingPersistenceType::Lapse),
11205            ot: crate::common::enums::StreamingOrderType::Limit,
11206            pd: 1617863365000,
11207            bsp: None,
11208            rfo: None,
11209            rfs: None,
11210            rc: None,
11211            rac: None,
11212            md: None,
11213            cd: None,
11214            ld: None,
11215            avp: Some(Decimal::new(20, 1)),
11216            sm: Some(Decimal::new(50, 0)),
11217            sr: Some(Decimal::ZERO),
11218            sl: None,
11219            sc: None,
11220            sv: Some(Decimal::new(20, 0)),
11221            lsrc: None,
11222        };
11223
11224        assert!(initial.is_some());
11225        assert_eq!(reports.len(), 1);
11226        assert_eq!(reports[0].last_qty, Quantity::from("20.00"));
11227        assert!(state.fill_tracker.has_unseen_fill_void(&update));
11228    }
11229
11230    #[rstest]
11231    fn test_ocm_state_sync_seeds_published_trade_ids_from_cache() {
11232        use crate::stream::parse::make_trade_id;
11233
11234        let mut state = OcmState::default();
11235
11236        // Seeded filled_qty < sm: cumulative-size gate would pass, so only
11237        // the trade-ids seeded by sync_from_orders can block the fill
11238        let uo_for_id = crate::stream::messages::UnmatchedOrder {
11239            id: "bet_seed".to_string(),
11240            p: Decimal::new(25, 1),
11241            s: Decimal::new(20, 0),
11242            side: crate::common::enums::StreamingSide::Back,
11243            status: crate::common::enums::StreamingOrderStatus::Executable,
11244            pt: Some(crate::common::enums::StreamingPersistenceType::Lapse),
11245            ot: crate::common::enums::StreamingOrderType::Limit,
11246            pd: 1617863365000,
11247            bsp: None,
11248            rfo: Some("O-SEED-001".to_string()),
11249            rfs: None,
11250            rc: None,
11251            rac: None,
11252            md: None,
11253            cd: None,
11254            ld: None,
11255            avp: Some(Decimal::new(25, 1)),
11256            sm: Some(Decimal::new(8, 0)),
11257            sr: None,
11258            sl: None,
11259            sc: None,
11260            sv: None,
11261            lsrc: None,
11262        };
11263        let trade_id = make_trade_id(&uo_for_id).to_string();
11264
11265        let orders = vec![OrderSyncEntry {
11266            bet_id: "bet_seed".to_string(),
11267            venue_order_ids: vec!["bet_seed".to_string()],
11268            client_order_id: ClientOrderId::from("O-SEED-001"),
11269            strategy_id: StrategyId::from("S-001"),
11270            filled_qty: Decimal::new(4, 0),
11271            avg_px: Decimal::new(25, 1),
11272            is_closed: false,
11273            trade_ids: vec![trade_id],
11274        }];
11275
11276        state.sync_from_orders(&orders);
11277
11278        let result = state.fill_tracker.maybe_fill_report(
11279            &uo_for_id,
11280            uo_for_id.s,
11281            InstrumentId::from("1.234567-12345-0.0.BETFAIR"),
11282            AccountId::from("BETFAIR-001"),
11283            Currency::from("GBP"),
11284            UnixNanos::default(),
11285            UnixNanos::default(),
11286        );
11287
11288        assert!(
11289            result.is_none(),
11290            "sync_from_orders must seed trade-ids so a known fill is not re-emitted \
11291             even when the cumulative-size gate would pass",
11292        );
11293    }
11294
11295    #[rstest]
11296    fn test_ocm_state_sync_from_orders_incremental_fill_after_sync() {
11297        let mut state = OcmState::default();
11298
11299        let orders = vec![OrderSyncEntry {
11300            bet_id: "bet_inc".to_string(),
11301            venue_order_ids: vec!["bet_inc".to_string()],
11302            client_order_id: ClientOrderId::from("O-INC-001"),
11303            strategy_id: StrategyId::from("S-001"),
11304            filled_qty: Decimal::new(10, 0),
11305            avg_px: Decimal::new(25, 1),
11306            is_closed: false,
11307            trade_ids: Vec::new(),
11308        }];
11309
11310        state.sync_from_orders(&orders);
11311
11312        // Stream update with sm=18 (8 more than synced 10)
11313        let uo = crate::stream::messages::UnmatchedOrder {
11314            id: "bet_inc".to_string(),
11315            p: Decimal::new(25, 1),
11316            s: Decimal::new(20, 0),
11317            side: crate::common::enums::StreamingSide::Lay,
11318            status: crate::common::enums::StreamingOrderStatus::Executable,
11319            pt: Some(crate::common::enums::StreamingPersistenceType::Persist),
11320            ot: crate::common::enums::StreamingOrderType::Limit,
11321            pd: 1617863365000,
11322            bsp: None,
11323            rfo: Some("O-INC-001".to_string()),
11324            rfs: None,
11325            rc: None,
11326            rac: None,
11327            md: None,
11328            cd: None,
11329            ld: None,
11330            avp: Some(Decimal::new(26, 1)),
11331            sm: Some(Decimal::new(18, 0)),
11332            sr: None,
11333            sl: None,
11334            sc: None,
11335            sv: None,
11336            lsrc: None,
11337        };
11338
11339        let instrument_id = InstrumentId::from("1.234567-12345-0.0.BETFAIR");
11340        let result = state.fill_tracker.maybe_fill_report(
11341            &uo,
11342            uo.s,
11343            instrument_id,
11344            AccountId::from("BETFAIR-001"),
11345            Currency::from("GBP"),
11346            UnixNanos::default(),
11347            UnixNanos::default(),
11348        );
11349
11350        let fill = result.expect("should produce incremental fill of 8");
11351        assert_eq!(fill.last_qty, Quantity::from("8.00"));
11352    }
11353
11354    #[rstest]
11355    fn test_ocm_state_sync_from_orders_zero_filled_not_synced() {
11356        let mut state = OcmState::default();
11357
11358        let orders = vec![OrderSyncEntry {
11359            bet_id: "bet_zero".to_string(),
11360            venue_order_ids: vec!["bet_zero".to_string()],
11361            client_order_id: ClientOrderId::from("O-ZERO-001"),
11362            strategy_id: StrategyId::from("S-001"),
11363            filled_qty: Decimal::ZERO,
11364            avg_px: Decimal::ZERO,
11365            is_closed: false,
11366            trade_ids: Vec::new(),
11367        }];
11368
11369        state.sync_from_orders(&orders);
11370
11371        // RFO should still be registered even if no fills
11372        let rfo = make_customer_order_ref("O-ZERO-001");
11373        assert!(state.resolve_client_order_id(Some(&rfo)).is_some());
11374
11375        // A stream update with sm=5 should produce a fill (not blocked by sync)
11376        let uo = crate::stream::messages::UnmatchedOrder {
11377            id: "bet_zero".to_string(),
11378            p: Decimal::new(30, 1),
11379            s: Decimal::new(10, 0),
11380            side: crate::common::enums::StreamingSide::Back,
11381            status: crate::common::enums::StreamingOrderStatus::Executable,
11382            pt: Some(crate::common::enums::StreamingPersistenceType::Lapse),
11383            ot: crate::common::enums::StreamingOrderType::Limit,
11384            pd: 1617863365000,
11385            bsp: None,
11386            rfo: None,
11387            rfs: None,
11388            rc: None,
11389            rac: None,
11390            md: None,
11391            cd: None,
11392            ld: None,
11393            avp: Some(Decimal::new(30, 1)),
11394            sm: Some(Decimal::new(5, 0)),
11395            sr: None,
11396            sl: None,
11397            sc: None,
11398            sv: None,
11399            lsrc: None,
11400        };
11401        let instrument_id = InstrumentId::from("1.234567-12345-0.0.BETFAIR");
11402        let result = state.fill_tracker.maybe_fill_report(
11403            &uo,
11404            uo.s,
11405            instrument_id,
11406            AccountId::from("BETFAIR-001"),
11407            Currency::from("GBP"),
11408            UnixNanos::default(),
11409            UnixNanos::default(),
11410        );
11411        assert!(
11412            result.is_some(),
11413            "zero-filled order should not block new fills"
11414        );
11415    }
11416
11417    #[rstest]
11418    fn test_ocm_state_sync_multiple_open_and_closed() {
11419        let mut state = OcmState::default();
11420
11421        let orders = vec![
11422            OrderSyncEntry {
11423                bet_id: "bet_a".to_string(),
11424                venue_order_ids: vec!["bet_a".to_string()],
11425                client_order_id: ClientOrderId::from("O-A"),
11426                strategy_id: StrategyId::from("S-001"),
11427                filled_qty: Decimal::new(5, 0),
11428                avg_px: Decimal::new(20, 1),
11429                is_closed: false,
11430                trade_ids: Vec::new(),
11431            },
11432            OrderSyncEntry {
11433                bet_id: "bet_b".to_string(),
11434                venue_order_ids: vec!["bet_b".to_string()],
11435                client_order_id: ClientOrderId::from("O-B"),
11436                strategy_id: StrategyId::from("S-001"),
11437                filled_qty: Decimal::ZERO,
11438                avg_px: Decimal::ZERO,
11439                is_closed: true,
11440                trade_ids: Vec::new(),
11441            },
11442            OrderSyncEntry {
11443                bet_id: "bet_c".to_string(),
11444                venue_order_ids: vec!["bet_c".to_string()],
11445                client_order_id: ClientOrderId::from("O-C"),
11446                strategy_id: StrategyId::from("S-001"),
11447                filled_qty: Decimal::new(100, 0),
11448                avg_px: Decimal::new(15, 1),
11449                is_closed: true,
11450                trade_ids: Vec::new(),
11451            },
11452            OrderSyncEntry {
11453                bet_id: "bet_d".to_string(),
11454                venue_order_ids: vec!["bet_d".to_string()],
11455                client_order_id: ClientOrderId::from("O-D"),
11456                strategy_id: StrategyId::from("S-001"),
11457                filled_qty: Decimal::ZERO,
11458                avg_px: Decimal::ZERO,
11459                is_closed: false,
11460                trade_ids: Vec::new(),
11461            },
11462        ];
11463
11464        state.sync_from_orders(&orders);
11465
11466        // Open orders have RFO registered
11467        assert!(
11468            state
11469                .resolve_client_order_id(Some(&make_customer_order_ref("O-A")))
11470                .is_some()
11471        );
11472        assert!(
11473            state
11474                .resolve_client_order_id(Some(&make_customer_order_ref("O-D")))
11475                .is_some()
11476        );
11477
11478        // Closed orders are terminal
11479        assert!(state.terminal_orders.contains("bet_b"));
11480        assert!(state.terminal_orders.contains("bet_c"));
11481        assert!(!state.terminal_orders.contains("bet_a"));
11482        assert!(!state.terminal_orders.contains("bet_d"));
11483
11484        assert_eq!(
11485            state.resolve_client_order_id(Some(&make_customer_order_ref("O-B"))),
11486            Some(ClientOrderId::from("O-B")),
11487        );
11488    }
11489
11490    fn make_summary(
11491        bet_id: &str,
11492        market_id: &str,
11493        selection_id: u64,
11494        handicap: Decimal,
11495        status: BetfairOrderStatus,
11496        placed_date: &str,
11497    ) -> CurrentOrderSummary {
11498        CurrentOrderSummary {
11499            bet_id: bet_id.to_string(),
11500            market_id: market_id.to_string(),
11501            selection_id,
11502            handicap,
11503            price_size: crate::http::models::PriceSize {
11504                price: Decimal::new(20, 1),
11505                size: Decimal::new(10, 0),
11506            },
11507            bsp_liability: Decimal::ZERO,
11508            side: BetfairSide::Back,
11509            status,
11510            persistence_type: PersistenceType::Lapse,
11511            order_type: BetfairOrderType::Limit,
11512            placed_date: placed_date.to_string(),
11513            matched_date: None,
11514            average_price_matched: None,
11515            size_matched: None,
11516            size_remaining: Some(Decimal::new(10, 0)),
11517            size_lapsed: None,
11518            size_cancelled: None,
11519            size_voided: None,
11520            regulator_auth_code: None,
11521            regulator_code: None,
11522            customer_order_ref: None,
11523            customer_strategy_ref: None,
11524        }
11525    }
11526
11527    #[rstest]
11528    fn test_select_order_for_query_single_executable() {
11529        let cid = ClientOrderId::from("O-001");
11530        let orders = vec![make_summary(
11531            "bet_1",
11532            "1.100",
11533            12345,
11534            Decimal::ZERO,
11535            BetfairOrderStatus::Executable,
11536            "2026-04-18T10:00:00Z",
11537        )];
11538        let expected = make_instrument_id("1.100", 12345, Decimal::ZERO);
11539
11540        let selected = select_order_for_query(&orders, expected, cid, None);
11541        assert_eq!(selected.map(|o| o.bet_id.as_str()), Some("bet_1"));
11542    }
11543
11544    #[rstest]
11545    fn test_select_order_for_query_single_terminal() {
11546        let cid = ClientOrderId::from("O-001");
11547        let orders = vec![make_summary(
11548            "bet_1",
11549            "1.100",
11550            12345,
11551            Decimal::ZERO,
11552            BetfairOrderStatus::ExecutionComplete,
11553            "2026-04-18T10:00:00Z",
11554        )];
11555        let expected = make_instrument_id("1.100", 12345, Decimal::ZERO);
11556
11557        let selected = select_order_for_query(&orders, expected, cid, None);
11558        assert_eq!(selected.map(|o| o.bet_id.as_str()), Some("bet_1"));
11559    }
11560
11561    #[rstest]
11562    fn test_select_order_for_query_replace_prefers_executable() {
11563        let cid = ClientOrderId::from("O-001");
11564        let orders = vec![
11565            make_summary(
11566                "bet_old",
11567                "1.100",
11568                12345,
11569                Decimal::ZERO,
11570                BetfairOrderStatus::ExecutionComplete,
11571                "2026-04-18T10:00:00Z",
11572            ),
11573            make_summary(
11574                "bet_new",
11575                "1.100",
11576                12345,
11577                Decimal::ZERO,
11578                BetfairOrderStatus::Executable,
11579                "2026-04-18T10:05:00Z",
11580            ),
11581        ];
11582        let expected = make_instrument_id("1.100", 12345, Decimal::ZERO);
11583
11584        let selected = select_order_for_query(&orders, expected, cid, None);
11585        assert_eq!(selected.map(|o| o.bet_id.as_str()), Some("bet_new"));
11586    }
11587
11588    #[rstest]
11589    fn test_select_order_for_query_multiple_executable_prefers_most_recent() {
11590        let cid = ClientOrderId::from("O-001");
11591        let orders = vec![
11592            make_summary(
11593                "bet_old",
11594                "1.100",
11595                12345,
11596                Decimal::ZERO,
11597                BetfairOrderStatus::Executable,
11598                "2026-04-18T10:00:00Z",
11599            ),
11600            make_summary(
11601                "bet_new",
11602                "1.100",
11603                12345,
11604                Decimal::ZERO,
11605                BetfairOrderStatus::Executable,
11606                "2026-04-18T10:05:00Z",
11607            ),
11608        ];
11609        let expected = make_instrument_id("1.100", 12345, Decimal::ZERO);
11610
11611        let selected = select_order_for_query(&orders, expected, cid, None);
11612        assert_eq!(selected.map(|o| o.bet_id.as_str()), Some("bet_new"));
11613    }
11614
11615    #[rstest]
11616    fn test_select_order_for_query_multiple_terminal_prefers_most_recent() {
11617        let cid = ClientOrderId::from("O-001");
11618        let orders = vec![
11619            make_summary(
11620                "bet_old",
11621                "1.100",
11622                12345,
11623                Decimal::ZERO,
11624                BetfairOrderStatus::ExecutionComplete,
11625                "2026-04-18T10:00:00Z",
11626            ),
11627            make_summary(
11628                "bet_new",
11629                "1.100",
11630                12345,
11631                Decimal::ZERO,
11632                BetfairOrderStatus::ExecutionComplete,
11633                "2026-04-18T10:05:00Z",
11634            ),
11635        ];
11636        let expected = make_instrument_id("1.100", 12345, Decimal::ZERO);
11637
11638        let selected = select_order_for_query(&orders, expected, cid, None);
11639        assert_eq!(selected.map(|o| o.bet_id.as_str()), Some("bet_new"));
11640    }
11641
11642    #[rstest]
11643    fn test_select_order_for_query_foreign_only_without_vid_returns_none() {
11644        let cid = ClientOrderId::from("O-001");
11645        let orders = vec![make_summary(
11646            "bet_foreign",
11647            "1.999",
11648            99999,
11649            Decimal::ZERO,
11650            BetfairOrderStatus::Executable,
11651            "2026-04-18T10:00:00Z",
11652        )];
11653        let expected = make_instrument_id("1.100", 12345, Decimal::ZERO);
11654
11655        let selected = select_order_for_query(&orders, expected, cid, None);
11656        assert!(selected.is_none());
11657    }
11658
11659    #[rstest]
11660    fn test_select_order_for_query_foreign_only_with_vid_match_returns_match() {
11661        let cid = ClientOrderId::from("O-001");
11662        let orders = vec![make_summary(
11663            "bet_foreign",
11664            "1.999",
11665            99999,
11666            Decimal::ZERO,
11667            BetfairOrderStatus::Executable,
11668            "2026-04-18T10:00:00Z",
11669        )];
11670        let expected = make_instrument_id("1.100", 12345, Decimal::ZERO);
11671        let vid = VenueOrderId::from("bet_foreign");
11672
11673        let selected = select_order_for_query(&orders, expected, cid, Some(vid));
11674        assert_eq!(selected.map(|o| o.bet_id.as_str()), Some("bet_foreign"));
11675    }
11676
11677    #[rstest]
11678    fn test_select_order_for_query_foreign_only_vid_mismatch_returns_none() {
11679        let cid = ClientOrderId::from("O-001");
11680        let orders = vec![
11681            make_summary(
11682                "bet_foreign_1",
11683                "1.999",
11684                99999,
11685                Decimal::ZERO,
11686                BetfairOrderStatus::Executable,
11687                "2026-04-18T10:00:00Z",
11688            ),
11689            make_summary(
11690                "bet_foreign_2",
11691                "1.888",
11692                88888,
11693                Decimal::ZERO,
11694                BetfairOrderStatus::Executable,
11695                "2026-04-18T10:05:00Z",
11696            ),
11697        ];
11698        let expected = make_instrument_id("1.100", 12345, Decimal::ZERO);
11699        let vid = VenueOrderId::from("bet_unknown");
11700
11701        let selected = select_order_for_query(&orders, expected, cid, Some(vid));
11702        assert!(selected.is_none());
11703    }
11704
11705    #[rstest]
11706    fn test_select_order_for_query_mixed_returns_matching_instrument() {
11707        let cid = ClientOrderId::from("O-001");
11708        let orders = vec![
11709            make_summary(
11710                "bet_foreign",
11711                "1.999",
11712                99999,
11713                Decimal::ZERO,
11714                BetfairOrderStatus::Executable,
11715                "2026-04-18T10:05:00Z",
11716            ),
11717            make_summary(
11718                "bet_match",
11719                "1.100",
11720                12345,
11721                Decimal::ZERO,
11722                BetfairOrderStatus::ExecutionComplete,
11723                "2026-04-18T10:00:00Z",
11724            ),
11725        ];
11726        let expected = make_instrument_id("1.100", 12345, Decimal::ZERO);
11727
11728        let selected = select_order_for_query(&orders, expected, cid, None);
11729        assert_eq!(selected.map(|o| o.bet_id.as_str()), Some("bet_match"));
11730    }
11731
11732    #[rstest]
11733    fn test_extend_unique_filters_duplicates() {
11734        let mut candidates: Vec<CurrentOrderSummary> = Vec::new();
11735        let mut seen: AHashSet<String> = AHashSet::new();
11736
11737        let orders = vec![
11738            make_summary(
11739                "bet_1",
11740                "1.100",
11741                12345,
11742                Decimal::ZERO,
11743                BetfairOrderStatus::Executable,
11744                "2026-04-18T10:00:00Z",
11745            ),
11746            make_summary(
11747                "bet_1",
11748                "1.100",
11749                12345,
11750                Decimal::ZERO,
11751                BetfairOrderStatus::Executable,
11752                "2026-04-18T10:01:00Z",
11753            ),
11754            make_summary(
11755                "bet_2",
11756                "1.100",
11757                12345,
11758                Decimal::ZERO,
11759                BetfairOrderStatus::Executable,
11760                "2026-04-18T10:02:00Z",
11761            ),
11762        ];
11763
11764        extend_unique(&mut candidates, &mut seen, orders);
11765
11766        assert_eq!(candidates.len(), 2);
11767        assert_eq!(candidates[0].bet_id, "bet_1");
11768        assert_eq!(candidates[0].placed_date, "2026-04-18T10:00:00Z");
11769        assert_eq!(candidates[1].bet_id, "bet_2");
11770        assert!(seen.contains("bet_1"));
11771        assert!(seen.contains("bet_2"));
11772    }
11773
11774    #[rstest]
11775    fn test_extend_unique_skips_already_seen() {
11776        let mut candidates: Vec<CurrentOrderSummary> = vec![make_summary(
11777            "bet_1",
11778            "1.100",
11779            12345,
11780            Decimal::ZERO,
11781            BetfairOrderStatus::Executable,
11782            "2026-04-18T10:00:00Z",
11783        )];
11784        let mut seen: AHashSet<String> = AHashSet::new();
11785        seen.insert("bet_1".to_string());
11786
11787        let orders = vec![make_summary(
11788            "bet_1",
11789            "1.100",
11790            12345,
11791            Decimal::ZERO,
11792            BetfairOrderStatus::Executable,
11793            "2026-04-18T10:05:00Z",
11794        )];
11795
11796        extend_unique(&mut candidates, &mut seen, orders);
11797
11798        assert_eq!(candidates.len(), 1);
11799        assert_eq!(candidates[0].placed_date, "2026-04-18T10:00:00Z");
11800    }
11801
11802    #[rstest]
11803    fn test_list_current_orders_filter_bet_id_sets_only_bet_ids() {
11804        let params = list_current_orders_filter_bet_id("bet_abc".to_string());
11805
11806        assert_eq!(
11807            params.bet_ids.as_deref(),
11808            Some(&["bet_abc".to_string()][..])
11809        );
11810        assert!(params.customer_order_refs.is_none());
11811        assert!(params.market_ids.is_none());
11812        assert!(params.order_projection.is_none());
11813        assert!(params.customer_strategy_refs.is_none());
11814        assert!(params.date_range.is_none());
11815        assert!(params.order_by.is_none());
11816        assert!(params.sort_dir.is_none());
11817        assert!(params.from_record.is_none());
11818        assert!(params.record_count.is_none());
11819    }
11820
11821    #[rstest]
11822    fn test_list_current_orders_filter_ref_sets_only_customer_order_refs() {
11823        let params = list_current_orders_filter_ref("rfo_abc".to_string());
11824
11825        assert_eq!(
11826            params.customer_order_refs.as_deref(),
11827            Some(&["rfo_abc".to_string()][..])
11828        );
11829        assert!(params.bet_ids.is_none());
11830        assert!(params.market_ids.is_none());
11831        assert!(params.order_projection.is_none());
11832        assert!(params.customer_strategy_refs.is_none());
11833        assert!(params.date_range.is_none());
11834        assert!(params.order_by.is_none());
11835        assert!(params.sort_dir.is_none());
11836        assert!(params.from_record.is_none());
11837        assert!(params.record_count.is_none());
11838    }
11839
11840    #[rstest]
11841    fn test_list_current_orders_supplemental_queries_batch_and_deduplicate_ids() {
11842        let bet_ids: Vec<_> = (0..251).map(|index| format!("bet-{index:03}")).collect();
11843        let queries = list_current_orders_supplemental_queries(
11844            bet_ids.iter().chain(&bet_ids).cloned().collect(),
11845            ["reference-b", "reference-a", "reference-a"]
11846                .into_iter()
11847                .map(String::from)
11848                .collect(),
11849        );
11850        let actual: Vec<_> = queries
11851            .into_iter()
11852            .map(|query| serde_json::to_value(query).unwrap())
11853            .collect();
11854        assert_eq!(
11855            actual,
11856            vec![
11857                serde_json::json!({"betIds": bet_ids[..250], "orderProjection": "ALL"}),
11858                serde_json::json!({"betIds": bet_ids[250..], "orderProjection": "ALL"}),
11859                serde_json::json!({"customerOrderRefs": ["reference-a"], "orderProjection": "ALL"}),
11860                serde_json::json!({"customerOrderRefs": ["reference-b"], "orderProjection": "ALL"}),
11861            ]
11862        );
11863        assert!(
11864            list_current_orders_supplemental_queries(AHashSet::new(), AHashSet::new()).is_empty()
11865        );
11866    }
11867
11868    #[rstest]
11869    fn test_order_status_supplemental_ids_use_known_bet_when_reference_is_ambiguous() {
11870        let first = ClientOrderId::from("12345678901234567890123456789012-first");
11871        let second = ClientOrderId::from("12345678901234567890123456789012-second");
11872        let mut state = OcmState::default();
11873        state.restore_order(
11874            first,
11875            StrategyId::from("S-001"),
11876            VenueOrderId::from("first-old"),
11877        );
11878        state.register_pending_replace(first, "first-old".to_string(), Some(Quantity::from(10)));
11879        state
11880            .complete_pending_replace(first, "first-old", VenueOrderId::from("first-new"))
11881            .unwrap();
11882        state.restore_order(
11883            second,
11884            StrategyId::from("S-002"),
11885            VenueOrderId::from("second-new"),
11886        );
11887        let mut order = make_summary(
11888            "first-new",
11889            "1.100",
11890            12345,
11891            Decimal::ZERO,
11892            BetfairOrderStatus::Executable,
11893            "2026-10-01T00:00:00Z",
11894        );
11895        order.customer_order_ref = Some(make_customer_order_ref_legacy(first.as_str()));
11896        assert_eq!(
11897            state.customer_order_ref_resolution(order.customer_order_ref.as_ref().unwrap()),
11898            Some(CustomerOrderRefResolution::Ambiguous)
11899        );
11900        let state = Arc::new(Mutex::new(state));
11901        assert_eq!(
11902            order_status_supplemental_ids(&[order], &state.lock()),
11903            (
11904                AHashSet::from_iter(["first-old".to_string(), "first-new".to_string(),]),
11905                AHashMap::new()
11906            )
11907        );
11908    }
11909
11910    #[rstest]
11911    fn test_list_current_orders_market_id_batches_respect_betfair_limit() {
11912        let market_ids = (0..=MAX_LIST_CURRENT_ORDERS_MARKET_IDS)
11913            .map(|index| format!("1.{index}"))
11914            .collect::<Vec<_>>();
11915
11916        let batches = list_current_orders_market_id_batches(Some(market_ids.clone()));
11917
11918        assert_eq!(
11919            batches,
11920            vec![
11921                Some(market_ids[..MAX_LIST_CURRENT_ORDERS_MARKET_IDS].to_vec()),
11922                Some(market_ids[MAX_LIST_CURRENT_ORDERS_MARKET_IDS..].to_vec()),
11923            ],
11924        );
11925    }
11926}