1use 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#[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 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 #[must_use]
250 pub fn is_reconciling(&self) -> bool {
251 self.reconciliation_gate.is_halted()
252 }
253
254 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 ¶ms,
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 *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, ¶ms)
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, ¶ms)
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 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 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 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, ¶ms)
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 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 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, ¶ms)
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, ¶ms)
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, ¶ms)
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, ¶ms)
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
3686fn 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#[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#[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 ¶ms,
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 ¶ms,
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 (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 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 if report.order_status == OrderStatus::Accepted && !report.filled_qty.is_zero() {
4741 report.order_status = OrderStatus::PartiallyFilled;
4742 }
4743 }
4744}
4745
4746fn 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 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 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#[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 ¶ms,
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
5310async 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#[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 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 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 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
5653fn 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
5740fn 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 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 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 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 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 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 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 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); 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 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 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 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 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; 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 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 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 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); 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 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 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 handler(br#"{"op":"connection","connectionId":"abc"}"#);
8667 assert!(reconnect_rx.try_recv().is_err());
8668
8669 handler(br#"{"op":"connection","connectionId":"def"}"#);
8671 assert!(reconnect_rx.try_recv().is_ok());
8672
8673 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 {
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 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 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 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 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 let rfo = make_customer_order_ref("O-ZERO-001");
11373 assert!(state.resolve_client_order_id(Some(&rfo)).is_some());
11374
11375 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 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 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}