1use ahash::{AHashMap, AHashSet};
23use nautilus_core::UnixNanos;
24use nautilus_model::{
25 data::{
26 BookOrder, InstrumentClose, InstrumentStatus, OrderBookDelta, OrderBookDeltas, TradeTick,
27 },
28 enums::{
29 AggressorSide, BookAction, InstrumentCloseType, LiquiditySide, MarketStatusAction,
30 OrderSide, OrderStatus, OrderType, RecordFlag, TimeInForce,
31 },
32 identifiers::{AccountId, ClientOrderId, InstrumentId, TradeId, VenueOrderId},
33 reports::{FillReport, OrderStatusReport},
34 types::{Currency, Money, Price, Quantity},
35};
36use rust_decimal::Decimal;
37
38use crate::{
39 common::{
40 enums::{
41 MarketStatus, RunnerStatus, StreamingOrderStatus, StreamingOrderType,
42 resolve_streaming_order_status,
43 },
44 parse::{
45 make_instrument_id, normalize_betfair_price, normalize_betfair_quantity,
46 parse_betfair_price, parse_betfair_quantity, parse_millis_timestamp,
47 },
48 },
49 data_types::{
50 BetfairBspBookDelta, BetfairCricketMatch, BetfairRaceProgress, BetfairRaceRunnerData,
51 BetfairStartingPrice, BetfairTicker,
52 },
53 stream::messages::{
54 CricketChange, MarketDefinition, RaceProgressChange, RaceRunnerChange, RunnerChange,
55 UnmatchedOrder,
56 },
57};
58
59pub fn parse_runner_book_deltas(
81 instrument_id: InstrumentId,
82 rc: &RunnerChange,
83 is_snapshot: bool,
84 sequence: u64,
85 ts_event: UnixNanos,
86 ts_init: UnixNanos,
87) -> anyhow::Result<Option<OrderBookDeltas>> {
88 let atb_len = rc.atb.as_ref().map_or(0, Vec::len);
89 let atl_len = rc.atl.as_ref().map_or(0, Vec::len);
90 let total_levels = atb_len + atl_len;
91
92 if total_levels == 0 && !is_snapshot {
93 return Ok(None);
94 }
95
96 let snapshot_flags = if is_snapshot {
97 RecordFlag::F_SNAPSHOT as u8
98 } else {
99 0
100 };
101 let mut deltas = Vec::with_capacity(total_levels + usize::from(is_snapshot));
102
103 if is_snapshot {
104 let mut clear = OrderBookDelta::clear(instrument_id, sequence, ts_event, ts_init);
105
106 if total_levels == 0 {
107 clear.flags |= RecordFlag::F_LAST as u8;
108 }
109 deltas.push(clear);
110 }
111
112 for (levels, side) in [
113 (rc.atb.as_deref().unwrap_or(&[]), OrderSide::Buy),
114 (rc.atl.as_deref().unwrap_or(&[]), OrderSide::Sell),
115 ] {
116 for pv in levels {
117 if is_snapshot && pv.volume == Decimal::ZERO {
118 continue;
119 }
120
121 let action = if is_snapshot {
122 BookAction::Add
123 } else if pv.volume == Decimal::ZERO {
124 BookAction::Delete
125 } else {
126 BookAction::Update
127 };
128
129 deltas.push(OrderBookDelta::new(
130 instrument_id,
131 action,
132 BookOrder::new(
133 side,
134 parse_betfair_price(pv.price)?,
135 parse_betfair_quantity(pv.volume)?,
136 0,
137 ),
138 snapshot_flags,
139 sequence,
140 ts_event,
141 ts_init,
142 ));
143 }
144 }
145
146 if let Some(last) = deltas.last_mut() {
148 last.flags |= RecordFlag::F_LAST as u8;
149 }
150
151 Ok(Some(OrderBookDeltas::new(instrument_id, deltas)))
152}
153
154#[must_use]
159pub fn make_trade_tick(
160 instrument_id: InstrumentId,
161 price: Price,
162 size: Quantity,
163 trade_id: TradeId,
164 ts_event: UnixNanos,
165 ts_init: UnixNanos,
166) -> TradeTick {
167 TradeTick::new(
168 instrument_id,
169 price,
170 size,
171 AggressorSide::NoAggressor,
172 trade_id,
173 ts_event,
174 ts_init,
175 )
176}
177
178#[must_use]
187pub fn parse_instrument_statuses(
188 market_id: &str,
189 def: &MarketDefinition,
190 ts_event: UnixNanos,
191 ts_init: UnixNanos,
192) -> Vec<InstrumentStatus> {
193 let Some(status) = def.status else {
194 return Vec::new();
195 };
196 let Some(runners) = &def.runners else {
197 return Vec::new();
198 };
199 let in_play = def.in_play.unwrap_or(false);
200
201 if status == MarketStatus::Unknown {
202 log::warn!("Skipping unmodeled Betfair market status for market {market_id}");
203 return Vec::new();
204 }
205
206 runners
207 .iter()
208 .filter_map(|rd| {
209 let handicap = rd.hc.unwrap_or(Decimal::ZERO);
210 let instrument_id = make_instrument_id(market_id, rd.id, handicap);
211 if rd.status == Some(RunnerStatus::Unknown) {
212 log::warn!("Skipping unmodeled Betfair runner status for {instrument_id}");
213 return None;
214 }
215 let action = match rd.status {
216 Some(RunnerStatus::Removed | RunnerStatus::RemovedVacant) => {
217 MarketStatusAction::Close
218 }
219 _ => match (status, in_play) {
220 (MarketStatus::Inactive, _) => MarketStatusAction::Close,
221 (MarketStatus::Open, false) => MarketStatusAction::PreOpen,
222 (MarketStatus::Open, true) => MarketStatusAction::Trading,
223 (MarketStatus::Suspended, _) => MarketStatusAction::Pause,
224 (MarketStatus::Closed, _) => MarketStatusAction::Close,
225 (MarketStatus::Unknown, _) => MarketStatusAction::None,
227 },
228 };
229 let is_trading = action == MarketStatusAction::Trading;
230 Some(InstrumentStatus::new(
231 instrument_id,
232 action,
233 ts_event,
234 ts_init,
235 None,
236 None,
237 Some(is_trading),
238 None,
239 None,
240 ))
241 })
242 .collect()
243}
244
245pub fn make_trade_id(uo: &UnmatchedOrder) -> TradeId {
250 let sm = normalize_betfair_quantity(uo.sm.unwrap_or(Decimal::ZERO));
251 make_trade_id_for_size(&uo.id, sm)
252}
253
254#[derive(Clone, Debug, Default)]
261pub struct FillTracker {
262 filled_qty: AHashMap<String, Decimal>,
263 voided_qty: AHashMap<String, Decimal>,
264 avg_px: AHashMap<String, Decimal>,
265 published_trade_ids: AHashSet<String>,
266 fill_lots: AHashMap<String, Vec<FillLot>>,
267 fill_voids: AHashMap<(String, TradeId), Decimal>,
268}
269
270#[derive(Debug, Clone)]
271struct FillLot {
272 trade_id: TradeId,
273 quantity: Decimal,
274 price: Price,
275 accounting_px: Price,
276}
277
278#[derive(Debug, Clone)]
280pub struct FillVoidAllocation {
281 pub trade_id: TradeId,
282 pub voided_qty: Quantity,
283 pub last_px: Price,
284}
285
286impl FillTracker {
287 #[must_use]
289 pub fn new() -> Self {
290 Self::default()
291 }
292
293 #[expect(clippy::too_many_arguments)]
300 pub fn maybe_fill_report(
301 &mut self,
302 uo: &UnmatchedOrder,
303 order_qty: Decimal,
304 instrument_id: InstrumentId,
305 account_id: AccountId,
306 currency: Currency,
307 ts_event: UnixNanos,
308 ts_init: UnixNanos,
309 ) -> Option<FillReport> {
310 let raw_sm = uo.sm?;
311 let sm = normalize_betfair_quantity(raw_sm);
312 let order_qty = normalize_betfair_quantity(resolve_stream_order_quantity(order_qty, uo));
313
314 if sm > order_qty {
315 log::warn!(
316 "Rejecting potential overfill for bet_id={}: order_qty={order_qty}, sm={sm}",
317 uo.id,
318 );
319 return None;
320 }
321
322 let (trade_id, last_qty, last_px) =
323 if uo.sv.is_some_and(|sv| sv > Decimal::ZERO) && self.has_fill_lots(&uo.id) {
324 self.advance_cumulative_fill_with_voids(
325 &uo.id,
326 raw_sm,
327 uo.sv.unwrap_or(Decimal::ZERO),
328 uo.avp,
329 uo.p,
330 )?
331 } else {
332 self.advance_cumulative_fill(&uo.id, raw_sm, uo.avp, uo.p)?
333 };
334
335 let venue_order_id = VenueOrderId::from(uo.id.as_str());
336 let order_side = OrderSide::from(uo.side);
337 let client_order_id = uo
338 .rfo
339 .as_deref()
340 .filter(|s| !s.is_empty())
341 .map(ClientOrderId::from);
342 let ts_fill = uo.md.map_or(ts_event, parse_millis_timestamp);
343
344 Some(make_fill_report(
345 account_id,
346 instrument_id,
347 venue_order_id,
348 trade_id,
349 order_side,
350 last_qty,
351 last_px,
352 currency,
353 client_order_id,
354 ts_fill,
355 ts_init,
356 ))
357 }
358
359 pub(crate) fn advance_cumulative_fill(
360 &mut self,
361 bet_id: &str,
362 raw_size_matched: Decimal,
363 average_price_matched: Option<Decimal>,
364 fallback_price: Decimal,
365 ) -> Option<(TradeId, Quantity, Price)> {
366 self.advance_cumulative_fill_inner(
367 bet_id,
368 raw_size_matched,
369 None,
370 average_price_matched,
371 fallback_price,
372 )
373 }
374
375 pub(crate) fn advance_cumulative_fill_with_voids(
376 &mut self,
377 bet_id: &str,
378 raw_size_matched: Decimal,
379 cumulative_voided: Decimal,
380 average_price_matched: Option<Decimal>,
381 fallback_price: Decimal,
382 ) -> Option<(TradeId, Quantity, Price)> {
383 self.advance_cumulative_fill_inner(
384 bet_id,
385 raw_size_matched,
386 Some(cumulative_voided),
387 average_price_matched,
388 fallback_price,
389 )
390 }
391
392 fn advance_cumulative_fill_inner(
393 &mut self,
394 bet_id: &str,
395 raw_size_matched: Decimal,
396 cumulative_voided: Option<Decimal>,
397 average_price_matched: Option<Decimal>,
398 fallback_price: Decimal,
399 ) -> Option<(TradeId, Quantity, Price)> {
400 let size_matched = normalize_betfair_quantity(raw_size_matched);
401 if size_matched <= Decimal::ZERO {
402 return None;
403 }
404
405 let previous_filled = self
406 .filled_qty
407 .get(bet_id)
408 .copied()
409 .map_or(Decimal::ZERO, normalize_betfair_quantity);
410
411 if size_matched == previous_filled {
412 let restatement =
413 self.matched_price_restatement(bet_id, cumulative_voided, average_price_matched);
414 if let Some((_, _, last_px)) = restatement {
415 self.set_surviving_accounting_px(bet_id, last_px);
416 }
417
418 self.record_cumulative_state(bet_id, size_matched, average_price_matched);
419 return restatement;
420 }
421
422 if size_matched < previous_filled {
423 return None;
424 }
425
426 let trade_id = make_trade_id_for_size(bet_id, size_matched);
427 let raw_trade_id = make_trade_id_for_size(bet_id, raw_size_matched);
428 if self.published_trade_ids.contains(trade_id.as_str())
429 || self.published_trade_ids.contains(raw_trade_id.as_str())
430 {
431 self.record_cumulative_state(bet_id, size_matched, average_price_matched);
432 self.published_trade_ids.insert(trade_id.to_string());
433 return None;
434 }
435
436 let fill_qty = size_matched - previous_filled;
437 let fill_price = if let Some(cumulative_voided) = cumulative_voided {
438 self.compute_fill_price_with_voids(
439 bet_id,
440 average_price_matched,
441 fallback_price,
442 size_matched,
443 fill_qty,
444 cumulative_voided,
445 )
446 } else {
447 self.compute_fill_price(
448 bet_id,
449 average_price_matched,
450 fallback_price,
451 previous_filled,
452 size_matched,
453 )
454 };
455 let last_qty = parse_betfair_quantity(fill_qty).ok()?;
456 let last_px = parse_betfair_price(fill_price).ok()?;
457
458 self.record_cumulative_state(bet_id, size_matched, average_price_matched);
459 self.published_trade_ids.insert(trade_id.to_string());
460 self.fill_lots
461 .entry(bet_id.to_string())
462 .or_default()
463 .push(FillLot {
464 trade_id,
465 quantity: fill_qty,
466 price: last_px,
467 accounting_px: last_px,
468 });
469
470 Some((trade_id, last_qty, last_px))
471 }
472
473 pub fn maybe_fill_voids(&mut self, uo: &UnmatchedOrder) -> Vec<FillVoidAllocation> {
477 let cumulative = normalize_betfair_quantity(uo.sv.unwrap_or(Decimal::ZERO));
478 let previous = self
479 .voided_qty
480 .get(&uo.id)
481 .copied()
482 .unwrap_or(Decimal::ZERO);
483
484 if cumulative <= previous {
485 return Vec::new();
486 }
487
488 let Some(lots) = self.fill_lots.get(&uo.id) else {
489 self.voided_qty.insert(uo.id.clone(), cumulative);
490 return Vec::new();
491 };
492 let mut remaining = cumulative - previous;
493 let mut desired = Vec::new();
494
495 for lot in lots.iter().rev() {
496 if remaining <= Decimal::ZERO {
497 break;
498 }
499 let key = (uo.id.clone(), lot.trade_id);
500 let prior = self.fill_voids.get(&key).copied().unwrap_or(Decimal::ZERO);
501 let available = lot.quantity.saturating_sub(prior);
502 let increment = remaining.min(available);
503 if increment > Decimal::ZERO {
504 desired.push((lot, prior + increment));
505 remaining -= increment;
506 }
507 }
508
509 if remaining > Decimal::ZERO {
510 log::warn!(
511 "Betfair cumulative void exceeds known fill lots for bet_id={}: sv={cumulative}, unmatched={remaining}",
512 uo.id,
513 );
514 return Vec::new();
515 }
516
517 let mut updates = Vec::new();
518
519 for (lot, allocation) in desired.into_iter().rev() {
520 let key = (uo.id.clone(), lot.trade_id);
521 let Ok(voided_qty) = parse_betfair_quantity(allocation) else {
522 continue;
523 };
524 self.fill_voids.insert(key, allocation);
525 updates.push(FillVoidAllocation {
526 trade_id: lot.trade_id,
527 voided_qty,
528 last_px: lot.price,
529 });
530 }
531 self.voided_qty.insert(uo.id.clone(), cumulative);
532 updates
533 }
534
535 #[must_use]
536 pub(crate) fn has_fill_lots(&self, bet_id: &str) -> bool {
537 self.fill_lots
538 .get(bet_id)
539 .is_some_and(|lots| !lots.is_empty())
540 }
541
542 #[must_use]
544 pub fn has_unseen_fill_void(&self, uo: &UnmatchedOrder) -> bool {
545 let cumulative = normalize_betfair_quantity(uo.sv.unwrap_or(Decimal::ZERO));
546 let previous = self
547 .voided_qty
548 .get(&uo.id)
549 .copied()
550 .unwrap_or(Decimal::ZERO);
551 cumulative > previous
552 }
553
554 #[must_use]
557 pub(crate) fn has_pending_price_restatement(
558 &self,
559 bet_id: &str,
560 size_matched: Decimal,
561 size_voided: Decimal,
562 average_price_matched: Option<Decimal>,
563 ) -> bool {
564 let size_voided = normalize_betfair_quantity(size_voided);
565 let previous_voided = self
566 .voided_qty
567 .get(bet_id)
568 .copied()
569 .unwrap_or(Decimal::ZERO);
570
571 if size_voided > previous_voided {
572 return false;
573 }
574
575 let size_matched = normalize_betfair_quantity(size_matched);
576 let cumulative = if self.has_fill_lots(bet_id) {
577 size_matched + size_voided
578 } else {
579 size_matched
580 };
581
582 let previous = self
583 .filled_qty
584 .get(bet_id)
585 .copied()
586 .unwrap_or(Decimal::ZERO);
587
588 if cumulative != previous || cumulative <= Decimal::ZERO {
589 return false;
590 }
591
592 self.matched_price_restatement(bet_id, Some(size_voided), average_price_matched)
593 .is_some()
594 }
595
596 #[must_use]
599 pub(crate) fn has_unseen_price_restatement(&self, uo: &UnmatchedOrder) -> bool {
600 self.has_pending_price_restatement(
601 &uo.id,
602 uo.sm.unwrap_or(Decimal::ZERO),
603 uo.sv.unwrap_or(Decimal::ZERO),
604 uo.avp,
605 )
606 }
607
608 #[must_use]
610 pub fn has_unseen_fill(&self, uo: &UnmatchedOrder) -> bool {
611 let size_matched = normalize_betfair_quantity(uo.sm.unwrap_or(Decimal::ZERO));
612 let cumulative = if self.has_fill_lots(&uo.id) {
613 size_matched + normalize_betfair_quantity(uo.sv.unwrap_or(Decimal::ZERO))
614 } else {
615 size_matched
616 };
617 let previous = self
618 .filled_qty
619 .get(&uo.id)
620 .copied()
621 .unwrap_or(Decimal::ZERO);
622 let order_qty = normalize_betfair_quantity(resolve_stream_order_quantity(uo.s, uo));
623 cumulative > previous && cumulative <= order_qty
624 }
625
626 pub(crate) fn sync_fill_lot(
627 &mut self,
628 bet_id: &str,
629 trade_id: TradeId,
630 quantity: Decimal,
631 price: Price,
632 voided_qty: Decimal,
633 ) {
634 let lots = self.fill_lots.entry(bet_id.to_string()).or_default();
635 if let Some(lot) = lots.iter_mut().find(|lot| lot.trade_id == trade_id) {
636 let stale_original = lot.accounting_px != price && price == lot.price;
637 if !stale_original {
638 lot.accounting_px = price;
639 }
640 } else {
641 lots.push(FillLot {
642 trade_id,
643 quantity: normalize_betfair_quantity(quantity),
644 price,
645 accounting_px: price,
646 });
647 }
648 let gross_filled = lots.iter().map(|lot| lot.quantity).sum();
649 self.filled_qty.insert(bet_id.to_string(), gross_filled);
650 self.published_trade_ids.insert(trade_id.to_string());
651 if voided_qty > Decimal::ZERO {
652 self.fill_voids.insert(
653 (bet_id.to_string(), trade_id),
654 normalize_betfair_quantity(voided_qty),
655 );
656 }
657 }
658
659 pub(crate) fn set_accounting_px(&mut self, bet_id: &str, trade_id: TradeId, price: Price) {
660 let Some(lots) = self.fill_lots.get_mut(bet_id) else {
661 return;
662 };
663
664 if let Some(lot) = lots.iter_mut().find(|lot| lot.trade_id == trade_id) {
665 lot.accounting_px = price;
666 }
667 }
668
669 pub(crate) fn matched_quantity(&self, bet_id: &str) -> Decimal {
670 let filled = self.filled_qty.get(bet_id).copied().unwrap_or_default();
671 let voided = self.voided_qty.get(bet_id).copied().unwrap_or_default();
672 (filled - voided).max(Decimal::ZERO)
673 }
674
675 pub(crate) fn voided_quantity(&self, bet_id: &str) -> Decimal {
676 self.voided_qty.get(bet_id).copied().unwrap_or_default()
677 }
678
679 pub(crate) fn sync_voided_qty(&mut self, bet_id: &str, voided_qty: Decimal) {
680 self.voided_qty
681 .insert(bet_id.to_string(), normalize_betfair_quantity(voided_qty));
682 }
683
684 fn matched_price_restatement(
685 &self,
686 bet_id: &str,
687 cumulative_voided: Option<Decimal>,
688 average_price_matched: Option<Decimal>,
689 ) -> Option<(TradeId, Quantity, Price)> {
690 if !self.size_voided_unchanged(bet_id, cumulative_voided) {
691 return None;
692 }
693
694 let avp = average_price_matched.map(normalize_betfair_price)?;
695 let prev_avg = self.avg_px.get(bet_id).copied()?;
696 if avp == prev_avg {
697 return None;
698 }
699
700 let (trade_id, surviving_qty) = self.single_surviving_lot(bet_id)?;
701
702 let Ok(last_qty) = parse_betfair_quantity(surviving_qty) else {
703 log::warn!("Cannot restate matched quantity {surviving_qty} for bet_id={bet_id}");
704 return None;
705 };
706
707 let Ok(last_px) = parse_betfair_price(avp) else {
708 log::warn!("Cannot restate matched price {avp} for bet_id={bet_id}");
709 return None;
710 };
711
712 Some((trade_id, last_qty, last_px))
713 }
714
715 fn set_surviving_accounting_px(&mut self, bet_id: &str, price: Price) {
716 let Some(lots) = self.fill_lots.get_mut(bet_id) else {
717 return;
718 };
719
720 for lot in lots.iter_mut() {
721 let voided = self
722 .fill_voids
723 .get(&(bet_id.to_string(), lot.trade_id))
724 .copied()
725 .unwrap_or(Decimal::ZERO);
726
727 if lot.quantity.saturating_sub(voided) > Decimal::ZERO {
728 lot.accounting_px = price;
729 }
730 }
731 }
732
733 fn size_voided_unchanged(&self, bet_id: &str, cumulative_voided: Option<Decimal>) -> bool {
734 let current = cumulative_voided.map_or(Decimal::ZERO, normalize_betfair_quantity);
735 let previous = self
736 .voided_qty
737 .get(bet_id)
738 .copied()
739 .unwrap_or(Decimal::ZERO);
740 current == previous
741 }
742
743 pub(crate) fn seed_missing_averages(&mut self) {
744 let bet_ids = self.fill_lots.keys().cloned().collect::<Vec<_>>();
745 for bet_id in bet_ids {
746 if self.avg_px.contains_key(&bet_id) {
747 continue;
748 }
749
750 let Some(lots) = self.fill_lots.get(&bet_id) else {
751 continue;
752 };
753
754 let mut quantity = Decimal::ZERO;
755 let mut notional = Decimal::ZERO;
756
757 for lot in lots {
758 let voided = self
759 .fill_voids
760 .get(&(bet_id.clone(), lot.trade_id))
761 .copied()
762 .unwrap_or(Decimal::ZERO);
763 let surviving = lot.quantity.saturating_sub(voided);
764 if surviving <= Decimal::ZERO {
765 continue;
766 }
767
768 quantity += surviving;
769 notional += surviving * lot.accounting_px.as_decimal();
770 }
771
772 if quantity > Decimal::ZERO {
773 self.avg_px.insert(bet_id, notional / quantity);
774 }
775 }
776 }
777
778 fn single_surviving_lot(&self, bet_id: &str) -> Option<(TradeId, Decimal)> {
779 let lots = self.fill_lots.get(bet_id)?;
780
781 let mut surviving = lots.iter().filter_map(|lot| {
782 let voided = self
783 .fill_voids
784 .get(&(bet_id.to_string(), lot.trade_id))
785 .copied()
786 .unwrap_or(Decimal::ZERO);
787 let surviving_qty = lot.quantity.saturating_sub(voided);
788 (surviving_qty > Decimal::ZERO).then_some((lot.trade_id, surviving_qty))
789 });
790
791 let lot = surviving.next()?;
792 surviving.next().is_none().then_some(lot)
793 }
794
795 fn record_cumulative_state(
796 &mut self,
797 bet_id: &str,
798 size_matched: Decimal,
799 average_price_matched: Option<Decimal>,
800 ) {
801 self.filled_qty.insert(bet_id.to_string(), size_matched);
802 if let Some(avg_px) = average_price_matched.map(normalize_betfair_price) {
803 self.avg_px.insert(bet_id.to_string(), avg_px);
804 }
805 }
806
807 fn compute_fill_price(
814 &self,
815 bet_id: &str,
816 average_price_matched: Option<Decimal>,
817 fallback_price: Decimal,
818 prev_filled: Decimal,
819 sm: Decimal,
820 ) -> Decimal {
821 let Some(avp) = average_price_matched.map(normalize_betfair_price) else {
822 return fallback_price;
823 };
824
825 if prev_filled == Decimal::ZERO {
826 return avp;
827 }
828
829 let Some(prev_avg) = self.avg_px.get(bet_id).copied() else {
830 return avp;
831 };
832
833 if prev_avg == avp {
834 return avp;
835 }
836
837 let fill_size = sm - prev_filled;
838
839 if fill_size == Decimal::ZERO {
840 return prev_avg;
841 }
842
843 let fill_price = (avp * sm - prev_avg * prev_filled) / fill_size;
844
845 if fill_price <= Decimal::ZERO {
846 log::warn!(
847 "Calculated fill price {fill_price} is invalid for bet_id={bet_id}, falling back to avp={avp}",
848 );
849 return avp;
850 }
851
852 fill_price
853 }
854
855 fn compute_fill_price_with_voids(
856 &self,
857 bet_id: &str,
858 average_price_matched: Option<Decimal>,
859 fallback_price: Decimal,
860 gross_matched: Decimal,
861 fill_qty: Decimal,
862 cumulative_voided: Decimal,
863 ) -> Decimal {
864 let Some(avp) = average_price_matched.map(normalize_betfair_price) else {
865 return fallback_price;
866 };
867 let cumulative_voided = normalize_betfair_quantity(cumulative_voided);
868 let previous_voided = self
869 .voided_qty
870 .get(bet_id)
871 .copied()
872 .map_or(Decimal::ZERO, normalize_betfair_quantity);
873 let incremental_void = cumulative_voided.saturating_sub(previous_voided);
874 let surviving_fill_qty = fill_qty.saturating_sub(incremental_void);
875 if surviving_fill_qty <= Decimal::ZERO {
876 return avp;
877 }
878
879 let mut prior_notional = Decimal::ZERO;
880 let mut effective_lots = Vec::new();
881
882 if let Some(lots) = self.fill_lots.get(bet_id) {
883 for lot in lots {
884 let already_voided = self
885 .fill_voids
886 .get(&(bet_id.to_string(), lot.trade_id))
887 .copied()
888 .unwrap_or(Decimal::ZERO);
889 let effective = lot.quantity.saturating_sub(already_voided);
890 prior_notional += effective * lot.accounting_px.as_decimal();
891 effective_lots.push((effective, lot.accounting_px.as_decimal()));
892 }
893 }
894
895 let mut prior_void = incremental_void.saturating_sub(fill_qty);
896 for (effective, price) in effective_lots.into_iter().rev() {
897 if prior_void <= Decimal::ZERO {
898 break;
899 }
900 let removed = prior_void.min(effective);
901 prior_notional -= removed * price;
902 prior_void -= removed;
903 }
904
905 let surviving_matched = gross_matched.saturating_sub(cumulative_voided);
906 let fill_price = (avp * surviving_matched - prior_notional) / surviving_fill_qty;
907 if fill_price <= Decimal::ZERO {
908 log::warn!(
909 "Calculated post-void fill price {fill_price} is invalid for bet_id={bet_id}, falling back to avp={avp}",
910 );
911 return avp;
912 }
913 fill_price
914 }
915
916 pub fn sync_order(&mut self, bet_id: &str, filled_qty: Decimal, avg_px: Decimal) {
922 let filled_qty = normalize_betfair_quantity(filled_qty);
923 let avg_px = normalize_betfair_price(avg_px);
924 let current = self
925 .filled_qty
926 .get(bet_id)
927 .copied()
928 .map_or(Decimal::ZERO, normalize_betfair_quantity);
929
930 if filled_qty > current {
931 self.filled_qty.insert(bet_id.to_string(), filled_qty);
932 if avg_px > Decimal::ZERO {
933 self.avg_px.insert(bet_id.to_string(), avg_px);
934 }
935 }
936 }
937
938 pub fn seed_published_trade_ids<I, S>(&mut self, trade_ids: I)
941 where
942 I: IntoIterator<Item = S>,
943 S: Into<String>,
944 {
945 for id in trade_ids {
946 self.published_trade_ids.insert(id.into());
947 }
948 }
949
950 pub fn prune(&mut self, bet_id: &str) {
952 self.filled_qty.remove(bet_id);
953 self.voided_qty.remove(bet_id);
954 self.avg_px.remove(bet_id);
955 self.fill_lots.remove(bet_id);
956 self.fill_voids.retain(|(id, _), _| id != bet_id);
957
958 let prefix = format!("{bet_id}-");
959 self.published_trade_ids
960 .retain(|id| !id.starts_with(&prefix));
961 }
962}
963
964fn make_trade_id_for_size(bet_id: &str, size_matched: Decimal) -> TradeId {
965 TradeId::new(format!("{bet_id}-{size_matched}"))
966}
967
968#[must_use]
970pub fn has_cancel_quantity(uo: &UnmatchedOrder) -> bool {
971 let sc = uo.sc.unwrap_or(Decimal::ZERO);
972 let sl = uo.sl.unwrap_or(Decimal::ZERO);
973 let sv = uo.sv.unwrap_or(Decimal::ZERO);
974 (sc + sl + sv) > Decimal::ZERO
975}
976
977#[must_use]
979pub fn is_lapsed(uo: &UnmatchedOrder) -> bool {
980 uo.status == StreamingOrderStatus::ExecutionComplete && uo.lsrc.is_some()
981}
982
983#[must_use]
990pub fn is_resting_sp_bet(uo: &UnmatchedOrder) -> bool {
991 uo.status == StreamingOrderStatus::ExecutionComplete
992 && matches!(
993 uo.ot,
994 StreamingOrderType::LimitOnClose | StreamingOrderType::MarketOnClose
995 )
996 && uo.sm.unwrap_or(Decimal::ZERO) <= Decimal::ZERO
997 && uo.lsrc.is_none()
998 && !has_cancel_quantity(uo)
999}
1000
1001pub fn parse_order_status_report(
1010 uo: &UnmatchedOrder,
1011 instrument_id: InstrumentId,
1012 account_id: AccountId,
1013 ts_event: UnixNanos,
1014 ts_init: UnixNanos,
1015) -> anyhow::Result<OrderStatusReport> {
1016 let order_side = OrderSide::from(uo.side);
1017 let order_type = OrderType::from(uo.ot);
1018 let time_in_force = parse_stream_time_in_force(uo)?;
1019
1020 let size_matched = uo.sm.unwrap_or(Decimal::ZERO);
1021 let size_cancelled = uo.sc.unwrap_or(Decimal::ZERO);
1022 let size_lapsed = uo.sl.unwrap_or(Decimal::ZERO);
1023 let size_voided = uo.sv.unwrap_or(Decimal::ZERO);
1024
1025 let size_closed = size_cancelled + size_lapsed + size_voided;
1027 let order_status = if uo.status == StreamingOrderStatus::ExecutionComplete
1028 && size_voided > Decimal::ZERO
1029 && size_cancelled.is_zero()
1030 && size_lapsed.is_zero()
1031 {
1032 OrderStatus::Voided
1033 } else if is_resting_sp_bet(uo) {
1034 OrderStatus::Accepted
1035 } else {
1036 resolve_streaming_order_status(uo.status, size_matched, size_closed)
1037 };
1038
1039 let quantity_decimal = stream_order_quantity(uo);
1040 anyhow::ensure!(
1041 quantity_decimal > Decimal::ZERO,
1042 "failed to resolve positive quantity for stream order update {} \
1043 (order_type={:?}, persistence_type={:?}, size={}, bsp_liability={:?}, \
1044 size_matched={:?}, size_remaining={:?}, size_cancelled={:?}, size_lapsed={:?}, size_voided={:?})",
1045 uo.id,
1046 uo.ot,
1047 uo.pt,
1048 uo.s,
1049 uo.bsp,
1050 uo.sm,
1051 uo.sr,
1052 uo.sc,
1053 uo.sl,
1054 uo.sv,
1055 );
1056 let quantity = parse_betfair_quantity(quantity_decimal)?;
1057 let filled_qty = parse_betfair_quantity(size_matched)?;
1058
1059 let ts_accepted = parse_millis_timestamp(uo.pd);
1060
1061 let ts_last = [uo.md, uo.cd, uo.ld]
1063 .into_iter()
1064 .flatten()
1065 .max()
1066 .map_or(ts_event, parse_millis_timestamp);
1067
1068 let venue_order_id = VenueOrderId::from(uo.id.as_str());
1069 let client_order_id = uo
1070 .rfo
1071 .as_deref()
1072 .filter(|s| !s.is_empty())
1073 .map(ClientOrderId::from);
1074
1075 let price = parse_betfair_price(uo.p)?;
1076
1077 let mut report = OrderStatusReport::new(
1078 account_id,
1079 instrument_id,
1080 client_order_id,
1081 venue_order_id,
1082 order_side.into(),
1083 order_type,
1084 time_in_force,
1085 order_status,
1086 quantity,
1087 filled_qty,
1088 ts_accepted,
1089 ts_last,
1090 ts_init,
1091 None,
1092 )
1093 .with_price(price);
1094
1095 report.avg_px = uo.avp;
1096 if let Some(lsrc) = uo.lsrc {
1097 report.cancel_reason = Some(lsrc.to_string());
1098 }
1099
1100 Ok(report)
1101}
1102
1103fn parse_stream_time_in_force(uo: &UnmatchedOrder) -> anyhow::Result<TimeInForce> {
1104 if matches!(
1105 uo.ot,
1106 StreamingOrderType::LimitOnClose | StreamingOrderType::MarketOnClose
1107 ) {
1108 return Ok(TimeInForce::AtTheClose);
1111 }
1112
1113 match uo.pt {
1114 Some(persistence_type) => Ok(TimeInForce::from(persistence_type)),
1115 None => anyhow::bail!("missing persistence type for order update {}", uo.id),
1116 }
1117}
1118
1119fn stream_order_quantity(uo: &UnmatchedOrder) -> Decimal {
1120 if uo.s > Decimal::ZERO {
1121 return uo.s;
1122 }
1123
1124 let lifecycle_qty = uo.sm.unwrap_or(Decimal::ZERO)
1125 + uo.sr.unwrap_or(Decimal::ZERO)
1126 + uo.sc.unwrap_or(Decimal::ZERO)
1127 + uo.sl.unwrap_or(Decimal::ZERO)
1128 + uo.sv.unwrap_or(Decimal::ZERO);
1129
1130 if lifecycle_qty > Decimal::ZERO {
1131 return lifecycle_qty;
1132 }
1133
1134 if uses_liability_based_stream_quantity(uo) {
1135 return uo.bsp.unwrap_or(Decimal::ZERO);
1136 }
1137
1138 Decimal::ZERO
1139}
1140
1141fn resolve_stream_order_quantity(order_qty: Decimal, uo: &UnmatchedOrder) -> Decimal {
1142 if order_qty > Decimal::ZERO {
1143 order_qty
1144 } else {
1145 stream_order_quantity(uo)
1146 }
1147}
1148
1149fn uses_liability_based_stream_quantity(uo: &UnmatchedOrder) -> bool {
1150 matches!(
1151 uo.ot,
1152 crate::common::enums::StreamingOrderType::LimitOnClose
1153 | crate::common::enums::StreamingOrderType::MarketOnClose
1154 )
1155}
1156
1157#[must_use]
1162#[expect(clippy::too_many_arguments)]
1163pub fn make_fill_report(
1164 account_id: AccountId,
1165 instrument_id: InstrumentId,
1166 venue_order_id: VenueOrderId,
1167 trade_id: TradeId,
1168 order_side: OrderSide,
1169 last_qty: Quantity,
1170 last_px: Price,
1171 currency: Currency,
1172 client_order_id: Option<ClientOrderId>,
1173 ts_event: UnixNanos,
1174 ts_init: UnixNanos,
1175) -> FillReport {
1176 FillReport::new(
1177 account_id,
1178 instrument_id,
1179 venue_order_id,
1180 trade_id,
1181 order_side,
1182 last_qty,
1183 last_px,
1184 Money::zero(currency),
1185 LiquiditySide::NoLiquiditySide,
1186 client_order_id,
1187 None,
1188 ts_event,
1189 ts_init,
1190 None,
1191 )
1192}
1193
1194#[must_use]
1198pub fn parse_betfair_ticker(
1199 instrument_id: InstrumentId,
1200 rc: &RunnerChange,
1201 ts_event: UnixNanos,
1202 ts_init: UnixNanos,
1203) -> Option<BetfairTicker> {
1204 if rc.ltp.is_none() && rc.tv.is_none() && rc.spn.is_none() && rc.spf.is_none() {
1205 return None;
1206 }
1207
1208 Some(BetfairTicker::new(
1209 instrument_id,
1210 rc.ltp,
1211 rc.tv,
1212 rc.spn,
1213 rc.spf,
1214 ts_event,
1215 ts_init,
1216 ))
1217}
1218
1219#[must_use]
1223pub fn parse_betfair_starting_prices(
1224 market_id: &str,
1225 def: &MarketDefinition,
1226 ts_event: UnixNanos,
1227 ts_init: UnixNanos,
1228) -> Vec<BetfairStartingPrice> {
1229 let Some(runners) = &def.runners else {
1230 return Vec::new();
1231 };
1232
1233 runners
1234 .iter()
1235 .filter_map(|rd| {
1236 let bsp = rd.bsp?;
1237 let handicap = rd.hc.unwrap_or(Decimal::ZERO);
1238 let instrument_id = make_instrument_id(market_id, rd.id, handicap);
1239 Some(BetfairStartingPrice::new(
1240 instrument_id,
1241 bsp,
1242 ts_event,
1243 ts_init,
1244 ))
1245 })
1246 .collect()
1247}
1248
1249#[must_use]
1255pub fn parse_bsp_book_deltas(
1256 instrument_id: InstrumentId,
1257 rc: &RunnerChange,
1258 ts_event: UnixNanos,
1259 ts_init: UnixNanos,
1260) -> Vec<BetfairBspBookDelta> {
1261 let spb_len = rc.spb.as_ref().map_or(0, Vec::len);
1262 let spl_len = rc.spl.as_ref().map_or(0, Vec::len);
1263
1264 if spb_len + spl_len == 0 {
1265 return Vec::new();
1266 }
1267
1268 let mut result = Vec::with_capacity(spb_len + spl_len);
1269
1270 for (levels, side) in [
1271 (rc.spb.as_deref().unwrap_or(&[]), OrderSide::Sell),
1272 (rc.spl.as_deref().unwrap_or(&[]), OrderSide::Buy),
1273 ] {
1274 for pv in levels {
1275 let action = if pv.volume == Decimal::ZERO {
1276 BookAction::Delete
1277 } else {
1278 BookAction::Update
1279 };
1280
1281 result.push(BetfairBspBookDelta::new(
1282 instrument_id,
1283 action,
1284 side,
1285 pv.price,
1286 pv.volume,
1287 ts_event,
1288 ts_init,
1289 ));
1290 }
1291 }
1292
1293 result
1294}
1295
1296#[must_use]
1301pub fn parse_instrument_closes(
1302 market_id: &str,
1303 def: &MarketDefinition,
1304 ts_event: UnixNanos,
1305 ts_init: UnixNanos,
1306) -> Vec<InstrumentClose> {
1307 let Some(runners) = &def.runners else {
1308 return Vec::new();
1309 };
1310
1311 runners
1312 .iter()
1313 .filter_map(|rd| {
1314 let status = rd.status.as_ref()?;
1315 let close_price = match status {
1316 RunnerStatus::Winner | RunnerStatus::Placed => Price::from("1.00"),
1317 RunnerStatus::Loser | RunnerStatus::Removed | RunnerStatus::RemovedVacant => {
1318 Price::from("0.00")
1319 }
1320 RunnerStatus::Active | RunnerStatus::Hidden | RunnerStatus::Unknown => return None,
1321 };
1322
1323 let handicap = rd.hc.unwrap_or(Decimal::ZERO);
1324 let instrument_id = make_instrument_id(market_id, rd.id, handicap);
1325
1326 Some(InstrumentClose::new(
1327 instrument_id,
1328 close_price,
1329 InstrumentCloseType::ContractExpired,
1330 ts_event,
1331 ts_init,
1332 ))
1333 })
1334 .collect()
1335}
1336
1337#[must_use]
1341pub fn parse_race_runner_data(
1342 race_id: &str,
1343 market_id: &str,
1344 rrc: &RaceRunnerChange,
1345 ts_event: UnixNanos,
1346 ts_init: UnixNanos,
1347) -> Option<BetfairRaceRunnerData> {
1348 let selection_id = rrc.id?;
1349
1350 Some(BetfairRaceRunnerData::new(
1351 race_id.to_string(),
1352 market_id.to_string(),
1353 selection_id,
1354 rrc.lat.unwrap_or(f64::NAN),
1355 rrc.lng.unwrap_or(f64::NAN),
1356 rrc.spd.unwrap_or(f64::NAN),
1357 rrc.prg.unwrap_or(f64::NAN),
1358 rrc.sfq.unwrap_or(f64::NAN),
1359 ts_event,
1360 ts_init,
1361 ))
1362}
1363
1364#[must_use]
1366pub fn parse_race_progress(
1367 race_id: &str,
1368 market_id: &str,
1369 rpc: &RaceProgressChange,
1370 ts_event: UnixNanos,
1371 ts_init: UnixNanos,
1372) -> BetfairRaceProgress {
1373 let order_json = serialize_json_value(rpc.ord.as_ref());
1374 let jumps_json = serialize_json_value(rpc.jumps.as_ref());
1375
1376 BetfairRaceProgress::new(
1377 race_id.to_string(),
1378 market_id.to_string(),
1379 rpc.g.clone().unwrap_or_default(),
1380 rpc.st.unwrap_or(f64::NAN),
1381 rpc.rt.unwrap_or(f64::NAN),
1382 rpc.spd.unwrap_or(f64::NAN),
1383 rpc.prg.unwrap_or(f64::NAN),
1384 order_json,
1385 jumps_json,
1386 ts_event,
1387 ts_init,
1388 )
1389}
1390
1391#[must_use]
1392pub fn parse_cricket_match(
1393 cricket: &CricketChange,
1394 ts_event: UnixNanos,
1395 ts_init: UnixNanos,
1396) -> Option<BetfairCricketMatch> {
1397 let event_id = cricket.event_id.clone()?;
1398 let market_id = cricket.market_id.clone()?;
1399
1400 Some(BetfairCricketMatch::new(
1401 event_id,
1402 market_id,
1403 serialize_json_value(cricket.fixture_info.as_ref()),
1404 serialize_json_value(cricket.home_team.as_ref()),
1405 serialize_json_value(cricket.away_team.as_ref()),
1406 serialize_json_value(cricket.match_stats.as_ref()),
1407 serialize_json_value(cricket.incident_list_wrapper.as_ref()),
1408 ts_event,
1409 ts_init,
1410 ))
1411}
1412
1413fn serialize_json_value<T>(value: Option<&T>) -> String
1414where
1415 T: serde::Serialize,
1416{
1417 value.map_or_default(|value| serde_json::to_string(value).unwrap_or_default())
1418}
1419
1420#[cfg(test)]
1421mod tests {
1422 use nautilus_model::enums::{MarketStatusAction, OrderStatus, TimeInForce};
1423 use rstest::rstest;
1424
1425 use super::*;
1426 use crate::{
1427 common::{
1428 consts::{BETFAIR_PRICE_PRECISION, BETFAIR_QUANTITY_PRECISION},
1429 enums::{StreamingOrderType, StreamingPersistenceType, StreamingSide},
1430 testing::load_test_json,
1431 },
1432 stream::messages::{PV, RunnerChange, RunnerDefinition, StreamMessage, stream_decode},
1433 };
1434
1435 fn assert_decimal_option_eq(actual: Option<Decimal>, expected: Decimal) {
1436 assert_eq!(actual, Some(expected));
1437 }
1438
1439 #[rstest]
1440 fn test_parse_runner_book_snapshot() {
1441 let data = load_test_json("stream/mcm_live_IMAGE.json");
1442 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1443
1444 if let StreamMessage::MarketChange(mcm) = msg {
1445 let mc = mcm.mc.as_ref().unwrap();
1446 let change = &mc[0];
1447 let rc = &change.rc.as_ref().unwrap()[0];
1448 let instrument_id = make_instrument_id(&change.id, rc.id, Decimal::ZERO);
1449
1450 let deltas = parse_runner_book_deltas(
1451 instrument_id,
1452 rc,
1453 true,
1454 mcm.pt,
1455 parse_millis_timestamp(mcm.pt),
1456 parse_millis_timestamp(mcm.pt),
1457 )
1458 .unwrap()
1459 .expect("should produce deltas");
1460
1461 let atb_len = rc.atb.as_ref().unwrap().len();
1463 let atl_len = rc.atl.as_ref().unwrap().len();
1464 assert_eq!(deltas.deltas.len(), 1 + atb_len + atl_len);
1465
1466 assert_eq!(deltas.deltas[0].action, BookAction::Clear);
1468 assert!(RecordFlag::F_SNAPSHOT.matches(deltas.deltas[0].flags));
1469
1470 for delta in &deltas.deltas[1..] {
1472 assert_eq!(delta.action, BookAction::Add);
1473 assert!(RecordFlag::F_SNAPSHOT.matches(delta.flags));
1474 }
1475
1476 let last = deltas.deltas.last().unwrap();
1478 assert!(RecordFlag::F_LAST.matches(last.flags));
1479
1480 let buy_count = deltas
1482 .deltas
1483 .iter()
1484 .filter(|d| d.order.side == Some(OrderSide::Buy))
1485 .count();
1486 let sell_count = deltas
1487 .deltas
1488 .iter()
1489 .filter(|d| d.order.side == Some(OrderSide::Sell))
1490 .count();
1491 assert_eq!(buy_count, atb_len);
1492 assert_eq!(sell_count, atl_len);
1493 } else {
1494 panic!("expected MarketChange");
1495 }
1496 }
1497
1498 #[rstest]
1499 fn test_parse_runner_book_snapshot_skips_zero_volume_levels() {
1500 let rc: RunnerChange = serde_json::from_str(
1501 r#"{
1502 "id": 123,
1503 "atb": [[2.0, 0.0], [2.1, 3.0]],
1504 "atl": [[2.2, 0.0], [2.3, 4.0]]
1505 }"#,
1506 )
1507 .unwrap();
1508 let instrument_id = make_instrument_id("1.234", rc.id, Decimal::ZERO);
1509
1510 let deltas = parse_runner_book_deltas(
1511 instrument_id,
1512 &rc,
1513 true,
1514 1_551_400_000_000,
1515 parse_millis_timestamp(1_551_400_000_000),
1516 parse_millis_timestamp(1_551_400_000_000),
1517 )
1518 .unwrap()
1519 .expect("should produce deltas");
1520
1521 assert_eq!(deltas.deltas.len(), 3);
1522 assert_eq!(deltas.deltas[0].action, BookAction::Clear);
1523 assert!(
1524 deltas
1525 .deltas
1526 .iter()
1527 .filter(|delta| delta.action == BookAction::Add)
1528 .all(|delta| !delta.order.size.is_zero())
1529 );
1530 }
1531
1532 #[rstest]
1533 fn test_parse_runner_book_update() {
1534 let data = load_test_json("stream/mcm_UPDATE.json");
1535 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1536
1537 if let StreamMessage::MarketChange(mcm) = msg {
1538 let mc = mcm.mc.as_ref().unwrap();
1539 let change = &mc[0];
1540 let rc = &change.rc.as_ref().unwrap()[0];
1541 let instrument_id = make_instrument_id(&change.id, rc.id, Decimal::ZERO);
1542
1543 let deltas = parse_runner_book_deltas(
1544 instrument_id,
1545 rc,
1546 false,
1547 mcm.pt,
1548 parse_millis_timestamp(mcm.pt),
1549 parse_millis_timestamp(mcm.pt),
1550 )
1551 .unwrap()
1552 .expect("should produce deltas");
1553
1554 assert!(deltas.deltas.iter().all(|d| d.action != BookAction::Clear));
1556
1557 let last = deltas.deltas.last().unwrap();
1559 assert!(RecordFlag::F_LAST.matches(last.flags));
1560
1561 for delta in &deltas.deltas {
1563 assert!(!RecordFlag::F_SNAPSHOT.matches(delta.flags));
1564 }
1565 } else {
1566 panic!("expected MarketChange");
1567 }
1568 }
1569
1570 #[rstest]
1571 fn test_parse_runner_book_update_zero_volume_is_delete() {
1572 let data = load_test_json("stream/mcm_UPDATE.json");
1573 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1574
1575 if let StreamMessage::MarketChange(mcm) = msg {
1576 let mc = mcm.mc.as_ref().unwrap();
1577 let change = &mc[0];
1578 let rc = &change.rc.as_ref().unwrap()[0];
1579 let instrument_id = make_instrument_id(&change.id, rc.id, Decimal::ZERO);
1580
1581 let deltas = parse_runner_book_deltas(
1582 instrument_id,
1583 rc,
1584 false,
1585 mcm.pt,
1586 parse_millis_timestamp(mcm.pt),
1587 parse_millis_timestamp(mcm.pt),
1588 )
1589 .unwrap()
1590 .unwrap();
1591
1592 assert!(
1594 deltas.deltas.iter().any(|d| d.action == BookAction::Delete),
1595 "zero volume should produce Delete action"
1596 );
1597 } else {
1598 panic!("expected MarketChange");
1599 }
1600 }
1601
1602 #[rstest]
1603 fn test_parse_runner_book_no_levels_returns_none() {
1604 let rc = RunnerChange {
1605 id: 12345,
1606 hc: None,
1607 atb: None,
1608 atl: None,
1609 batb: None,
1610 batl: None,
1611 bdatb: None,
1612 bdatl: None,
1613 spb: None,
1614 spl: None,
1615 spn: None,
1616 spf: None,
1617 trd: None,
1618 ltp: None,
1619 tv: None,
1620 };
1621
1622 let result = parse_runner_book_deltas(
1623 make_instrument_id("1.123", 12345, Decimal::ZERO),
1624 &rc,
1625 false,
1626 0,
1627 UnixNanos::default(),
1628 UnixNanos::default(),
1629 );
1630
1631 assert!(result.unwrap().is_none());
1632 }
1633
1634 #[rstest]
1635 fn test_make_trade_tick() {
1636 let instrument_id = make_instrument_id("1.180737206", 19248890, Decimal::ZERO);
1637 let tick = make_trade_tick(
1638 instrument_id,
1639 Price::new(2.42, BETFAIR_PRICE_PRECISION),
1640 Quantity::new(100.0, BETFAIR_QUANTITY_PRECISION),
1641 TradeId::from("test-trade-1"),
1642 UnixNanos::default(),
1643 UnixNanos::default(),
1644 );
1645
1646 assert_eq!(tick.instrument_id, instrument_id);
1647 assert_eq!(tick.price.as_f64(), 2.42);
1648 assert_eq!(tick.size.as_f64(), 100.0);
1649 assert_eq!(tick.aggressor_side, AggressorSide::NoAggressor);
1650 }
1651
1652 fn make_status_def(
1653 status: MarketStatus,
1654 in_play: bool,
1655 runner_status: RunnerStatus,
1656 ) -> MarketDefinition {
1657 MarketDefinition {
1658 runners: Some(vec![RunnerDefinition {
1659 id: 456,
1660 hc: None,
1661 sort_priority: None,
1662 name: None,
1663 status: Some(runner_status),
1664 adjustment_factor: None,
1665 bsp: None,
1666 removal_date: None,
1667 }]),
1668 bet_delay: None,
1669 betting_type: None,
1670 bsp_market: None,
1671 bsp_reconciled: None,
1672 competition_id: None,
1673 competition_name: None,
1674 complete: None,
1675 country_code: None,
1676 cross_matching: None,
1677 discount_allowed: None,
1678 each_way_divisor: None,
1679 event_id: None,
1680 event_name: None,
1681 event_type_id: None,
1682 event_type_name: None,
1683 in_play: Some(in_play),
1684 line_interval: None,
1685 line_max_unit: None,
1686 line_min_unit: None,
1687 market_base_rate: None,
1688 market_id: None,
1689 market_name: None,
1690 market_time: None,
1691 market_type: None,
1692 number_of_active_runners: None,
1693 number_of_winners: None,
1694 open_date: None,
1695 persistence_enabled: None,
1696 price_ladder_definition: None,
1697 race_type: None,
1698 regulators: None,
1699 runners_voidable: None,
1700 settled_time: None,
1701 status: Some(status),
1702 suspend_time: None,
1703 timezone: None,
1704 turn_in_play_enabled: None,
1705 venue: None,
1706 version: None,
1707 }
1708 }
1709
1710 #[rstest]
1711 #[case(MarketStatus::Open, false, MarketStatusAction::PreOpen, false)]
1712 #[case(MarketStatus::Open, true, MarketStatusAction::Trading, true)]
1713 #[case(MarketStatus::Closed, false, MarketStatusAction::Close, false)]
1714 #[case(MarketStatus::Closed, true, MarketStatusAction::Close, false)]
1715 #[case(MarketStatus::Suspended, false, MarketStatusAction::Pause, false)]
1716 #[case(MarketStatus::Suspended, true, MarketStatusAction::Pause, false)]
1717 #[case(MarketStatus::Inactive, false, MarketStatusAction::Close, false)]
1718 fn test_parse_instrument_statuses_market_state(
1719 #[case] status: MarketStatus,
1720 #[case] in_play: bool,
1721 #[case] expected_action: MarketStatusAction,
1722 #[case] expected_is_trading: bool,
1723 ) {
1724 let def = make_status_def(status, in_play, RunnerStatus::Active);
1725 let results =
1726 parse_instrument_statuses("1.123", &def, UnixNanos::default(), UnixNanos::default());
1727
1728 assert_eq!(results.len(), 1);
1729 assert_eq!(results[0].action, expected_action);
1730 assert_eq!(results[0].is_trading, Some(expected_is_trading));
1731 }
1732
1733 #[rstest]
1734 fn test_parse_instrument_statuses_skips_unknown_market_status() {
1735 let def = make_status_def(MarketStatus::Unknown, true, RunnerStatus::Active);
1738 let results =
1739 parse_instrument_statuses("1.123", &def, UnixNanos::default(), UnixNanos::default());
1740
1741 assert!(results.is_empty());
1742 }
1743
1744 #[rstest]
1745 fn test_parse_instrument_statuses_skips_unknown_runner() {
1746 let def = make_status_def(MarketStatus::Open, true, RunnerStatus::Unknown);
1749 let results =
1750 parse_instrument_statuses("1.123", &def, UnixNanos::default(), UnixNanos::default());
1751
1752 assert!(results.is_empty());
1753 }
1754
1755 #[rstest]
1756 #[case(RunnerStatus::Removed)]
1757 #[case(RunnerStatus::RemovedVacant)]
1758 fn test_parse_instrument_statuses_scratched_runner_closes(#[case] runner_status: RunnerStatus) {
1759 let def = make_status_def(MarketStatus::Open, true, runner_status);
1761 let results =
1762 parse_instrument_statuses("1.123", &def, UnixNanos::default(), UnixNanos::default());
1763
1764 assert_eq!(results.len(), 1);
1765 assert_eq!(results[0].action, MarketStatusAction::Close);
1766 assert_eq!(results[0].is_trading, Some(false));
1767 }
1768
1769 #[rstest]
1770 #[case::missing_runners("runners")]
1771 #[case::missing_status("status")]
1772 fn test_parse_instrument_statuses_returns_empty(#[case] drop_field: &str) {
1773 let mut def = make_status_def(MarketStatus::Open, true, RunnerStatus::Active);
1774 match drop_field {
1775 "runners" => def.runners = None,
1776 "status" => def.status = None,
1777 _ => unreachable!(),
1778 }
1779
1780 let results =
1781 parse_instrument_statuses("1.123", &def, UnixNanos::default(), UnixNanos::default());
1782
1783 assert!(results.is_empty());
1784 }
1785
1786 #[rstest]
1787 fn test_parse_instrument_statuses_mixed_runners() {
1788 let mut def = make_status_def(MarketStatus::Open, true, RunnerStatus::Active);
1792 def.runners = Some(vec![
1793 RunnerDefinition {
1794 id: 101,
1795 hc: None,
1796 sort_priority: Some(1),
1797 name: None,
1798 status: Some(RunnerStatus::Active),
1799 adjustment_factor: None,
1800 bsp: None,
1801 removal_date: None,
1802 },
1803 RunnerDefinition {
1804 id: 202,
1805 hc: Some(Decimal::new(25, 1)), sort_priority: Some(2),
1807 name: None,
1808 status: Some(RunnerStatus::Removed),
1809 adjustment_factor: None,
1810 bsp: None,
1811 removal_date: None,
1812 },
1813 RunnerDefinition {
1814 id: 303,
1815 hc: None,
1816 sort_priority: Some(3),
1817 name: None,
1818 status: Some(RunnerStatus::RemovedVacant),
1819 adjustment_factor: None,
1820 bsp: None,
1821 removal_date: None,
1822 },
1823 ]);
1824
1825 let results =
1826 parse_instrument_statuses("1.999", &def, UnixNanos::default(), UnixNanos::default());
1827
1828 assert_eq!(results.len(), 3);
1829
1830 assert_eq!(results[0].action, MarketStatusAction::Trading);
1831 assert_eq!(results[0].is_trading, Some(true));
1832
1833 assert_eq!(results[1].action, MarketStatusAction::Close);
1834 assert_eq!(results[1].is_trading, Some(false));
1835
1836 assert_eq!(results[2].action, MarketStatusAction::Close);
1837 assert_eq!(results[2].is_trading, Some(false));
1838
1839 assert_ne!(results[0].instrument_id, results[1].instrument_id);
1841 assert_ne!(results[1].instrument_id, results[2].instrument_id);
1842 assert_ne!(results[0].instrument_id, results[2].instrument_id);
1843 }
1844
1845 #[rstest]
1846 fn test_parse_order_status_report_new_order() {
1847 let data = load_test_json("stream/ocm_NEW_FULL_IMAGE.json");
1848 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1849
1850 if let StreamMessage::OrderChange(ocm) = msg {
1851 let oc = ocm.oc.as_ref().unwrap();
1852 let omc = &oc[0];
1853 let orc = &omc.orc.as_ref().unwrap()[0];
1854 let uo = &orc.uo.as_ref().unwrap()[0];
1855
1856 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
1857 let report = parse_order_status_report(
1858 uo,
1859 instrument_id,
1860 AccountId::from("BETFAIR-001"),
1861 parse_millis_timestamp(ocm.pt),
1862 parse_millis_timestamp(ocm.pt),
1863 )
1864 .unwrap();
1865
1866 assert_eq!(report.order_status, OrderStatus::PartiallyFilled);
1868 assert_eq!(report.order_side, Some(OrderSide::Sell)); assert_eq!(report.order_type, OrderType::Limit);
1870 assert_eq!(report.filled_qty.as_f64(), 4.75);
1871 assert_eq!(report.quantity.as_f64(), 5.0);
1872 assert!(report.price.is_some());
1873 assert_eq!(report.price.unwrap().as_f64(), 12.0);
1874 } else {
1875 panic!("expected OrderChange");
1876 }
1877 }
1878
1879 #[rstest]
1880 fn test_parse_order_status_report_filled() {
1881 let data = load_test_json("stream/ocm_FILLED.json");
1882 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1883
1884 if let StreamMessage::OrderChange(ocm) = msg {
1885 let oc = ocm.oc.as_ref().unwrap();
1886 let omc = &oc[0];
1887 let orc = &omc.orc.as_ref().unwrap()[0];
1888 let uo = &orc.uo.as_ref().unwrap()[0];
1889
1890 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
1891 let report = parse_order_status_report(
1892 uo,
1893 instrument_id,
1894 AccountId::from("BETFAIR-001"),
1895 parse_millis_timestamp(ocm.pt),
1896 parse_millis_timestamp(ocm.pt),
1897 )
1898 .unwrap();
1899
1900 assert_eq!(report.order_status, OrderStatus::Filled);
1901 assert_eq!(report.order_side, Some(OrderSide::Buy)); assert_eq!(report.filled_qty.as_f64(), 10.0);
1903 assert_eq!(report.quantity.as_f64(), 10.0);
1904
1905 assert!(report.client_order_id.is_some());
1907 } else {
1908 panic!("expected OrderChange");
1909 }
1910 }
1911
1912 #[rstest]
1913 fn test_parse_order_status_report_cancelled() {
1914 let data = load_test_json("stream/ocm_CANCEL.json");
1915 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1916
1917 if let StreamMessage::OrderChange(ocm) = msg {
1918 let oc = ocm.oc.as_ref().unwrap();
1919 let omc = &oc[0];
1920 let orc = &omc.orc.as_ref().unwrap()[0];
1921 let uo = &orc.uo.as_ref().unwrap()[0];
1922
1923 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
1924 let report = parse_order_status_report(
1925 uo,
1926 instrument_id,
1927 AccountId::from("BETFAIR-001"),
1928 parse_millis_timestamp(ocm.pt),
1929 parse_millis_timestamp(ocm.pt),
1930 )
1931 .unwrap();
1932
1933 assert_eq!(report.order_status, OrderStatus::Canceled);
1934 assert_eq!(report.order_side, Some(OrderSide::Sell)); assert_eq!(report.filled_qty.as_f64(), 0.0);
1936 assert_eq!(report.quantity.as_f64(), 10.0);
1937 } else {
1938 panic!("expected OrderChange");
1939 }
1940 }
1941
1942 #[rstest]
1943 fn test_parse_order_status_report_duplicate_execution() {
1944 let data = load_test_json("stream/ocm_DUPLICATE_EXECUTION.json");
1945 let msgs: Vec<StreamMessage> = serde_json::from_str(&data).unwrap();
1946
1947 if let StreamMessage::OrderChange(ocm) = &msgs[0] {
1948 let oc = ocm.oc.as_ref().unwrap();
1949 let omc = &oc[0];
1950 let orc = &omc.orc.as_ref().unwrap()[0];
1951 let uo = &orc.uo.as_ref().unwrap()[0];
1952
1953 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
1954 let report = parse_order_status_report(
1955 uo,
1956 instrument_id,
1957 AccountId::from("BETFAIR-001"),
1958 parse_millis_timestamp(ocm.pt),
1959 parse_millis_timestamp(ocm.pt),
1960 )
1961 .unwrap();
1962
1963 assert_eq!(report.order_status, OrderStatus::PartiallyFilled);
1965 assert_eq!(report.order_side, Some(OrderSide::Buy)); assert_eq!(report.filled_qty.as_f64(), 1.12);
1967 } else {
1968 panic!("expected OrderChange");
1969 }
1970 }
1971
1972 #[rstest]
1973 fn test_parse_order_status_report_sp_resting() {
1974 let data = load_test_json("stream/ocm_SP_RESTING.json");
1975 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1976
1977 if let StreamMessage::OrderChange(ocm) = msg {
1978 let oc = ocm.oc.as_ref().unwrap();
1979 let omc = &oc[0];
1980 let orc = &omc.orc.as_ref().unwrap()[0];
1981 let uo = &orc.uo.as_ref().unwrap()[0];
1982
1983 assert!(is_resting_sp_bet(uo));
1984
1985 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
1986 let report = parse_order_status_report(
1987 uo,
1988 instrument_id,
1989 AccountId::from("BETFAIR-001"),
1990 parse_millis_timestamp(ocm.pt),
1991 parse_millis_timestamp(ocm.pt),
1992 )
1993 .unwrap();
1994
1995 assert_eq!(report.order_status, OrderStatus::Accepted);
1999 assert_eq!(report.time_in_force, TimeInForce::AtTheClose);
2000 assert_eq!(report.order_side, Some(OrderSide::Sell)); assert_eq!(report.filled_qty.as_f64(), 0.0);
2002 assert_eq!(report.quantity.as_f64(), 2.0);
2003 } else {
2004 panic!("expected OrderChange");
2005 }
2006 }
2007
2008 fn sp_unmatched_order(size_matched: Decimal, size_lapsed: Decimal) -> UnmatchedOrder {
2009 UnmatchedOrder {
2010 id: "442849719274".to_string(),
2011 p: Decimal::new(10000, 1),
2012 s: Decimal::ZERO,
2013 side: StreamingSide::Back,
2014 status: StreamingOrderStatus::ExecutionComplete,
2015 pt: Some(StreamingPersistenceType::MarketOnClose),
2016 ot: StreamingOrderType::MarketOnClose,
2017 pd: 1789423573000,
2018 bsp: Some(Decimal::new(2, 0)),
2019 rfo: None,
2020 rfs: None,
2021 rc: None,
2022 rac: None,
2023 md: None,
2024 cd: None,
2025 ld: None,
2026 avp: None,
2027 sm: Some(size_matched),
2028 sr: Some(Decimal::ZERO),
2029 sl: Some(size_lapsed),
2030 sc: Some(Decimal::ZERO),
2031 sv: Some(Decimal::ZERO),
2032 lsrc: None,
2033 }
2034 }
2035
2036 #[rstest]
2037 fn test_parse_order_status_report_sp_reconciled() {
2038 let matched = sp_unmatched_order(Decimal::new(2, 0), Decimal::ZERO);
2041 assert!(!is_resting_sp_bet(&matched));
2042
2043 let report = parse_order_status_report(
2044 &matched,
2045 InstrumentId::from("1.262362241-6532924-0.BETFAIR"),
2046 AccountId::from("BETFAIR-001"),
2047 UnixNanos::default(),
2048 UnixNanos::default(),
2049 )
2050 .unwrap();
2051
2052 assert_eq!(report.order_status, OrderStatus::Filled);
2053 assert_eq!(report.filled_qty.as_f64(), 2.0);
2054 assert_eq!(report.quantity.as_f64(), 2.0);
2055
2056 let lapsed = sp_unmatched_order(Decimal::ZERO, Decimal::new(2, 0));
2057 assert!(!is_resting_sp_bet(&lapsed));
2058
2059 let report = parse_order_status_report(
2060 &lapsed,
2061 InstrumentId::from("1.262362241-6532924-0.BETFAIR"),
2062 AccountId::from("BETFAIR-001"),
2063 UnixNanos::default(),
2064 UnixNanos::default(),
2065 )
2066 .unwrap();
2067
2068 assert_eq!(report.order_status, OrderStatus::Canceled);
2069 }
2070
2071 #[rstest]
2072 fn test_parse_order_status_report_multiple_fills() {
2073 let data = load_test_json("stream/ocm_multiple_fills.json");
2074 let msgs: Vec<StreamMessage> = serde_json::from_str(&data).unwrap();
2075
2076 if let StreamMessage::OrderChange(ocm) = &msgs[0] {
2077 let oc = ocm.oc.as_ref().unwrap();
2078 let omc = &oc[0];
2079 let orc = &omc.orc.as_ref().unwrap()[0];
2080 let uo = &orc.uo.as_ref().unwrap()[0];
2081
2082 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
2083 let report = parse_order_status_report(
2084 uo,
2085 instrument_id,
2086 AccountId::from("BETFAIR-001"),
2087 parse_millis_timestamp(ocm.pt),
2088 parse_millis_timestamp(ocm.pt),
2089 )
2090 .unwrap();
2091
2092 assert_eq!(report.order_status, OrderStatus::PartiallyFilled);
2094 assert_eq!(report.order_side, Some(OrderSide::Sell)); assert_eq!(report.filled_qty.as_f64(), 16.19);
2096 assert!(report.client_order_id.is_some());
2097 assert!(report.avg_px.is_some());
2098 } else {
2099 panic!("expected OrderChange");
2100 }
2101 }
2102
2103 #[rstest]
2104 fn test_parse_runner_book_snapshot_empty_book() {
2105 let rc = RunnerChange {
2107 id: 12345,
2108 hc: None,
2109 atb: Some(vec![]),
2110 atl: Some(vec![]),
2111 batb: None,
2112 batl: None,
2113 bdatb: None,
2114 bdatl: None,
2115 spb: None,
2116 spl: None,
2117 spn: None,
2118 spf: None,
2119 trd: None,
2120 ltp: None,
2121 tv: None,
2122 };
2123
2124 let result = parse_runner_book_deltas(
2125 make_instrument_id("1.123", 12345, Decimal::ZERO),
2126 &rc,
2127 true,
2128 1000,
2129 UnixNanos::default(),
2130 UnixNanos::default(),
2131 )
2132 .unwrap()
2133 .expect("should produce snapshot deltas");
2134
2135 assert_eq!(result.deltas.len(), 1);
2137 assert_eq!(result.deltas[0].action, BookAction::Clear);
2138 assert!(RecordFlag::F_LAST.matches(result.deltas[0].flags));
2139 assert!(RecordFlag::F_SNAPSHOT.matches(result.deltas[0].flags));
2140 }
2141
2142 #[rstest]
2143 fn test_make_fill_report() {
2144 let instrument_id = make_instrument_id("1.180604981", 1209555, Decimal::ZERO);
2145 let fill = make_fill_report(
2146 AccountId::from("BETFAIR-001"),
2147 instrument_id,
2148 VenueOrderId::from("229430281339"),
2149 TradeId::from("229430281339-0"),
2150 OrderSide::Buy,
2151 Quantity::new(10.0, BETFAIR_QUANTITY_PRECISION),
2152 Price::new(1.1, BETFAIR_PRICE_PRECISION),
2153 Currency::GBP(),
2154 None,
2155 UnixNanos::default(),
2156 UnixNanos::default(),
2157 );
2158
2159 assert_eq!(fill.instrument_id, instrument_id);
2160 assert_eq!(fill.order_side, OrderSide::Buy);
2161 assert_eq!(fill.last_qty.as_f64(), 10.0);
2162 assert_eq!(fill.last_px.as_f64(), 1.1);
2163 assert_eq!(fill.commission.as_f64(), 0.0);
2164 assert_eq!(fill.liquidity_side, LiquiditySide::NoLiquiditySide);
2165 }
2166
2167 #[rstest]
2168 fn test_fill_tracker_single_full_fill() {
2169 let data = load_test_json("stream/ocm_FILLED.json");
2170 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2171
2172 if let StreamMessage::OrderChange(ocm) = msg {
2173 let oc = ocm.oc.as_ref().unwrap();
2174 let omc = &oc[0];
2175 let orc = &omc.orc.as_ref().unwrap()[0];
2176 let uo = &orc.uo.as_ref().unwrap()[0];
2177 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
2178 let ts = parse_millis_timestamp(ocm.pt);
2179
2180 let mut tracker = FillTracker::new();
2181 let fill = tracker
2182 .maybe_fill_report(
2183 uo,
2184 uo.s,
2185 instrument_id,
2186 AccountId::from("BETFAIR-001"),
2187 Currency::GBP(),
2188 ts,
2189 ts,
2190 )
2191 .expect("should produce fill");
2192
2193 assert_eq!(fill.last_qty.as_f64(), 10.0);
2194 assert_eq!(fill.last_px.as_f64(), 1.1);
2195 assert_eq!(fill.order_side, OrderSide::Buy);
2196 assert!(fill.client_order_id.is_some());
2197 } else {
2198 panic!("expected OrderChange");
2199 }
2200 }
2201
2202 #[rstest]
2203 fn test_fill_tracker_incremental_fills() {
2204 let data = load_test_json("stream/ocm_multiple_fills.json");
2205 let msgs: Vec<StreamMessage> = serde_json::from_str(&data).unwrap();
2206 let instrument_id = make_instrument_id("1.179082386", 50210, Decimal::ZERO);
2207
2208 let mut tracker = FillTracker::new();
2209 let account_id = AccountId::from("BETFAIR-001");
2210 let currency = Currency::GBP();
2211
2212 let uo1 = extract_uo(&msgs[0]);
2214 let ts1 = extract_ts(&msgs[0]);
2215 let fill1 = tracker
2216 .maybe_fill_report(uo1, uo1.s, instrument_id, account_id, currency, ts1, ts1)
2217 .expect("should produce first fill");
2218 assert_eq!(fill1.last_qty.as_f64(), 16.19);
2219 assert_eq!(fill1.last_px.as_f64(), 5.8);
2220
2221 let uo2 = extract_uo(&msgs[1]);
2223 let ts2 = extract_ts(&msgs[1]);
2224 let fill2 = tracker
2225 .maybe_fill_report(uo2, uo2.s, instrument_id, account_id, currency, ts2, ts2)
2226 .expect("should produce second fill");
2227 assert_eq!(fill2.last_qty.as_f64(), 0.77);
2228 assert_eq!(fill2.last_px.as_f64(), 5.8);
2229
2230 let uo3 = extract_uo(&msgs[2]);
2232 let ts3 = extract_ts(&msgs[2]);
2233 let fill3 = tracker
2234 .maybe_fill_report(uo3, uo3.s, instrument_id, account_id, currency, ts3, ts3)
2235 .expect("should produce third fill");
2236 assert_eq!(fill3.last_qty.as_f64(), 0.77);
2237 }
2238
2239 #[rstest]
2240 fn test_fill_tracker_different_price() {
2241 let data = load_test_json("stream/ocm_filled_different_price.json");
2242 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2243
2244 if let StreamMessage::OrderChange(ocm) = msg {
2245 let oc = ocm.oc.as_ref().unwrap();
2246 let omc = &oc[0];
2247 let orc = &omc.orc.as_ref().unwrap()[0];
2248 let uo = &orc.uo.as_ref().unwrap()[0];
2249 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
2250 let ts = parse_millis_timestamp(ocm.pt);
2251
2252 let mut tracker = FillTracker::new();
2253 let fill = tracker
2254 .maybe_fill_report(
2255 uo,
2256 uo.s,
2257 instrument_id,
2258 AccountId::from("BETFAIR-001"),
2259 Currency::GBP(),
2260 ts,
2261 ts,
2262 )
2263 .expect("should produce fill");
2264
2265 assert_eq!(fill.last_qty.as_f64(), 20.0);
2267 assert_eq!(fill.last_px.as_f64(), 1.2);
2268 } else {
2269 panic!("expected OrderChange");
2270 }
2271 }
2272
2273 #[rstest]
2274 fn test_fill_tracker_cancel_no_fill() {
2275 let data = load_test_json("stream/ocm_CANCEL.json");
2276 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2277
2278 if let StreamMessage::OrderChange(ocm) = msg {
2279 let oc = ocm.oc.as_ref().unwrap();
2280 let omc = &oc[0];
2281 let orc = &omc.orc.as_ref().unwrap()[0];
2282 let uo = &orc.uo.as_ref().unwrap()[0];
2283 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
2284 let ts = parse_millis_timestamp(ocm.pt);
2285
2286 let mut tracker = FillTracker::new();
2287 let result = tracker.maybe_fill_report(
2288 uo,
2289 uo.s,
2290 instrument_id,
2291 AccountId::from("BETFAIR-001"),
2292 Currency::GBP(),
2293 ts,
2294 ts,
2295 );
2296 assert!(result.is_none(), "cancelled order should not produce fill");
2297 } else {
2298 panic!("expected OrderChange");
2299 }
2300 }
2301
2302 #[rstest]
2303 fn test_fill_tracker_lapsed_no_fill() {
2304 let data = load_test_json("stream/ocm_error_fill.json");
2305 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2306
2307 if let StreamMessage::OrderChange(ocm) = msg {
2308 let oc = ocm.oc.as_ref().unwrap();
2309 let omc = &oc[0];
2310 let orc = &omc.orc.as_ref().unwrap()[0];
2311 let uo = &orc.uo.as_ref().unwrap()[0];
2312 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
2313 let ts = parse_millis_timestamp(ocm.pt);
2314
2315 let mut tracker = FillTracker::new();
2316 let result = tracker.maybe_fill_report(
2317 uo,
2318 uo.s,
2319 instrument_id,
2320 AccountId::from("BETFAIR-001"),
2321 Currency::GBP(),
2322 ts,
2323 ts,
2324 );
2325 assert!(result.is_none(), "lapsed order should not produce fill");
2326 } else {
2327 panic!("expected OrderChange");
2328 }
2329 }
2330
2331 #[rstest]
2332 fn test_fill_tracker_duplicate_dedup() {
2333 let data = load_test_json("stream/ocm_FILLED.json");
2334 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2335
2336 if let StreamMessage::OrderChange(ocm) = msg {
2337 let oc = ocm.oc.as_ref().unwrap();
2338 let omc = &oc[0];
2339 let orc = &omc.orc.as_ref().unwrap()[0];
2340 let uo = &orc.uo.as_ref().unwrap()[0];
2341 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
2342 let ts = parse_millis_timestamp(ocm.pt);
2343 let account_id = AccountId::from("BETFAIR-001");
2344 let currency = Currency::GBP();
2345
2346 let mut tracker = FillTracker::new();
2347
2348 let fill1 =
2350 tracker.maybe_fill_report(uo, uo.s, instrument_id, account_id, currency, ts, ts);
2351 assert!(fill1.is_some());
2352
2353 let fill2 =
2355 tracker.maybe_fill_report(uo, uo.s, instrument_id, account_id, currency, ts, ts);
2356 assert!(fill2.is_none(), "duplicate fill should be suppressed");
2357 } else {
2358 panic!("expected OrderChange");
2359 }
2360 }
2361
2362 #[rstest]
2363 fn test_fill_tracker_price_back_calculation() {
2364 let data = load_test_json("stream/ocm_multiple_fills.json");
2365 let msgs: Vec<StreamMessage> = serde_json::from_str(&data).unwrap();
2366 let instrument_id = make_instrument_id("1.179082386", 50210, Decimal::ZERO);
2367 let account_id = AccountId::from("BETFAIR-001");
2368 let currency = Currency::GBP();
2369 let mut tracker = FillTracker::new();
2370
2371 let uo1 = extract_uo(&msgs[0]);
2373 let ts1 = extract_ts(&msgs[0]);
2374 let fill1 = tracker
2375 .maybe_fill_report(uo1, uo1.s, instrument_id, account_id, currency, ts1, ts1)
2376 .unwrap();
2377 assert_eq!(fill1.last_px.as_f64(), 5.8);
2378
2379 let uo2 = extract_uo(&msgs[1]);
2381 let ts2 = extract_ts(&msgs[1]);
2382 let fill2 = tracker
2383 .maybe_fill_report(uo2, uo2.s, instrument_id, account_id, currency, ts2, ts2)
2384 .unwrap();
2385 assert_eq!(fill2.last_px.as_f64(), 5.8);
2386 }
2387
2388 #[rstest]
2389 fn test_has_cancel_quantity() {
2390 let data = load_test_json("stream/ocm_CANCEL.json");
2391 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2392
2393 if let StreamMessage::OrderChange(ocm) = msg {
2394 let uo = &ocm.oc.as_ref().unwrap()[0].orc.as_ref().unwrap()[0]
2395 .uo
2396 .as_ref()
2397 .unwrap()[0];
2398 assert!(has_cancel_quantity(uo));
2399 } else {
2400 panic!("expected OrderChange");
2401 }
2402 }
2403
2404 #[rstest]
2405 fn test_has_cancel_quantity_filled_order() {
2406 let data = load_test_json("stream/ocm_FILLED.json");
2407 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2408
2409 if let StreamMessage::OrderChange(ocm) = msg {
2410 let uo = &ocm.oc.as_ref().unwrap()[0].orc.as_ref().unwrap()[0]
2411 .uo
2412 .as_ref()
2413 .unwrap()[0];
2414 assert!(!has_cancel_quantity(uo));
2415 } else {
2416 panic!("expected OrderChange");
2417 }
2418 }
2419
2420 fn extract_uo(msg: &StreamMessage) -> &UnmatchedOrder {
2421 if let StreamMessage::OrderChange(ocm) = msg {
2422 &ocm.oc.as_ref().unwrap()[0].orc.as_ref().unwrap()[0]
2423 .uo
2424 .as_ref()
2425 .unwrap()[0]
2426 } else {
2427 panic!("expected OrderChange")
2428 }
2429 }
2430
2431 fn extract_ts(msg: &StreamMessage) -> UnixNanos {
2432 if let StreamMessage::OrderChange(ocm) = msg {
2433 parse_millis_timestamp(ocm.pt)
2434 } else {
2435 panic!("expected OrderChange")
2436 }
2437 }
2438
2439 #[rstest]
2440 fn test_parse_race_runner_data_from_fixture() {
2441 let data = load_test_json("stream/rcm_single.json");
2442 let msg = stream_decode(data.as_bytes()).unwrap();
2443
2444 let StreamMessage::RaceChange(rcm) = msg else {
2445 panic!("expected RaceChange");
2446 };
2447
2448 let race = &rcm.rc.as_ref().unwrap()[0];
2449 let rrc = &race.rrc.as_ref().unwrap()[0];
2450 let ts = parse_millis_timestamp(rcm.pt);
2451
2452 let runner = parse_race_runner_data(
2453 race.id.as_deref().unwrap(),
2454 race.mid.as_deref().unwrap(),
2455 rrc,
2456 ts,
2457 ts,
2458 )
2459 .unwrap();
2460
2461 assert_eq!(runner.race_id, "28587288.1650");
2462 assert_eq!(runner.market_id, "1.1234567");
2463 assert_eq!(runner.selection_id, 7390417);
2464 assert!((runner.latitude - 51.4189543).abs() < 1e-6);
2465 assert!((runner.longitude - (-0.4058491)).abs() < 1e-6);
2466 assert!((runner.speed - 17.8).abs() < 1e-6);
2467 assert!((runner.progress - 2051.0).abs() < 1e-6);
2468 assert!((runner.stride_frequency - 2.07).abs() < 1e-6);
2469 }
2470
2471 #[rstest]
2472 fn test_parse_race_progress_from_fixture() {
2473 let data = load_test_json("stream/rcm_single.json");
2474 let msg = stream_decode(data.as_bytes()).unwrap();
2475
2476 let StreamMessage::RaceChange(rcm) = msg else {
2477 panic!("expected RaceChange");
2478 };
2479
2480 let race = &rcm.rc.as_ref().unwrap()[0];
2481 let rpc = race.rpc.as_ref().unwrap();
2482 let ts = parse_millis_timestamp(rcm.pt);
2483
2484 let progress = parse_race_progress(
2485 race.id.as_deref().unwrap(),
2486 race.mid.as_deref().unwrap(),
2487 rpc,
2488 ts,
2489 ts,
2490 );
2491
2492 assert_eq!(progress.race_id, "28587288.1650");
2493 assert_eq!(progress.market_id, "1.1234567");
2494 assert_eq!(progress.gate_name, "1f");
2495 assert!((progress.sectional_time - 10.6).abs() < 1e-6);
2496 assert!((progress.running_time - 46.7).abs() < 1e-6);
2497 assert!((progress.speed - 17.8).abs() < 1e-6);
2498 assert!((progress.progress - 87.5).abs() < 1e-6);
2499
2500 let order: Vec<i64> = serde_json::from_str(&progress.order).unwrap();
2501 assert_eq!(order, vec![7390417, 5600338, 11527189, 6395118, 8706072]);
2502
2503 let jumps: Vec<serde_json::Value> = serde_json::from_str(&progress.jumps).unwrap();
2504 assert_eq!(jumps.len(), 2);
2505 assert_eq!(jumps[0]["J"], 2);
2506 }
2507
2508 #[rstest]
2509 fn test_parse_cricket_match_from_fixture() {
2510 let data = load_test_json("stream/ccm_single.json");
2511 let msg = stream_decode(data.as_bytes()).unwrap();
2512
2513 let StreamMessage::CricketChange(ccm) = msg else {
2514 panic!("expected CricketChange");
2515 };
2516
2517 let change = &ccm.cc.as_ref().unwrap()[0];
2518 let ts = parse_millis_timestamp(ccm.pt);
2519 let cricket = parse_cricket_match(change, ts, ts).unwrap();
2520
2521 assert_eq!(cricket.event_id, "35741575");
2522 assert_eq!(cricket.market_id, "1.259334639");
2523 let stats: serde_json::Value = serde_json::from_str(&cricket.match_stats).unwrap();
2524 assert_eq!(stats["inningsStats"][0]["inningsRuns"], 100);
2525 }
2526
2527 #[rstest]
2528 #[case(None, Some("1.259334639".to_string()))]
2529 #[case(Some("35741575".to_string()), None)]
2530 fn test_parse_cricket_match_missing_required_id_returns_none(
2531 #[case] event_id: Option<String>,
2532 #[case] market_id: Option<String>,
2533 ) {
2534 let change = CricketChange {
2535 event_id,
2536 market_id,
2537 fixture_info: None,
2538 home_team: None,
2539 away_team: None,
2540 match_stats: Some(serde_json::json!({"inningsStats": []})),
2541 incident_list_wrapper: None,
2542 };
2543 let ts = UnixNanos::from(1_000_000_000u64);
2544 let result = parse_cricket_match(&change, ts, ts);
2545
2546 assert!(result.is_none());
2547 }
2548
2549 #[rstest]
2550 fn test_parse_race_runner_data_multi_runner() {
2551 let data = load_test_json("stream/rcm_multi_runner.json");
2552 let msg = stream_decode(data.as_bytes()).unwrap();
2553
2554 let StreamMessage::RaceChange(rcm) = msg else {
2555 panic!("expected RaceChange");
2556 };
2557
2558 let race = &rcm.rc.as_ref().unwrap()[0];
2559 let ts = parse_millis_timestamp(rcm.pt);
2560 let race_id = race.id.as_deref().unwrap();
2561 let market_id = race.mid.as_deref().unwrap();
2562
2563 let runners: Vec<_> = race
2564 .rrc
2565 .as_ref()
2566 .unwrap()
2567 .iter()
2568 .filter_map(|rrc| parse_race_runner_data(race_id, market_id, rrc, ts, ts))
2569 .collect();
2570
2571 assert_eq!(runners.len(), 5);
2572 assert_eq!(runners[0].selection_id, 35467839);
2573 assert_eq!(runners[4].selection_id, 41694785);
2574 assert!((runners[0].speed - 16.33).abs() < 1e-6);
2575 assert!((runners[4].speed - 17.11).abs() < 1e-6);
2576 }
2577
2578 #[rstest]
2579 fn test_parse_race_runner_data_missing_id_returns_none() {
2580 let rrc = RaceRunnerChange {
2581 ft: Some(1000),
2582 id: None,
2583 lat: Some(51.0),
2584 lng: Some(-0.4),
2585 spd: Some(15.0),
2586 prg: Some(500.0),
2587 sfq: Some(2.0),
2588 };
2589 let ts = UnixNanos::from(1_000_000_000u64);
2590 let result = parse_race_runner_data("race1", "market1", &rrc, ts, ts);
2591 assert!(result.is_none());
2592 }
2593
2594 #[rstest]
2595 fn test_parse_race_runner_data_absent_fields_are_nan() {
2596 let rrc = RaceRunnerChange {
2597 ft: None,
2598 id: Some(12345),
2599 lat: None,
2600 lng: None,
2601 spd: None,
2602 prg: None,
2603 sfq: None,
2604 };
2605 let ts = UnixNanos::from(1_000_000_000u64);
2606 let runner = parse_race_runner_data("race1", "market1", &rrc, ts, ts).unwrap();
2607 assert!(runner.latitude.is_nan());
2608 assert!(runner.longitude.is_nan());
2609 assert!(runner.speed.is_nan());
2610 assert!(runner.progress.is_nan());
2611 assert!(runner.stride_frequency.is_nan());
2612 }
2613
2614 #[rstest]
2615 fn test_parse_race_progress_absent_fields() {
2616 let rpc = RaceProgressChange {
2617 ft: None,
2618 g: None,
2619 st: None,
2620 rt: None,
2621 spd: None,
2622 prg: None,
2623 ord: None,
2624 jumps: None,
2625 };
2626 let ts = UnixNanos::from(1_000_000_000u64);
2627 let progress = parse_race_progress("race1", "market1", &rpc, ts, ts);
2628 assert_eq!(progress.gate_name, "");
2629 assert!(progress.sectional_time.is_nan());
2630 assert!(progress.running_time.is_nan());
2631 assert_eq!(progress.order, "");
2632 assert_eq!(progress.jumps, "");
2633 }
2634
2635 fn runner_change_with_ticker(
2636 id: u64,
2637 ltp: Option<Decimal>,
2638 tv: Option<Decimal>,
2639 spn: Option<Decimal>,
2640 spf: Option<Decimal>,
2641 ) -> RunnerChange {
2642 RunnerChange {
2643 id,
2644 hc: None,
2645 atb: None,
2646 atl: None,
2647 batb: None,
2648 batl: None,
2649 bdatb: None,
2650 bdatl: None,
2651 spb: None,
2652 spl: None,
2653 spn,
2654 spf,
2655 trd: None,
2656 ltp,
2657 tv,
2658 }
2659 }
2660
2661 #[rstest]
2662 fn test_parse_betfair_ticker_all_fields() {
2663 let rc = runner_change_with_ticker(
2664 9249757,
2665 Some(Decimal::new(55, 1)),
2666 Some(Decimal::new(189032, 2)),
2667 Some(Decimal::new(568, 2)),
2668 Some(Decimal::new(573, 2)),
2669 );
2670 let ts = UnixNanos::from(1_000_000_000u64);
2671 let instrument_id = make_instrument_id("1.185781465", 9249757, Decimal::ZERO);
2672
2673 let ticker = parse_betfair_ticker(instrument_id, &rc, ts, ts).unwrap();
2674
2675 assert_eq!(ticker.instrument_id, instrument_id);
2676 assert_decimal_option_eq(ticker.last_traded_price, Decimal::new(55, 1));
2677 assert_decimal_option_eq(ticker.traded_volume, Decimal::new(189032, 2));
2678 assert_decimal_option_eq(ticker.starting_price_near, Decimal::new(568, 2));
2679 assert_decimal_option_eq(ticker.starting_price_far, Decimal::new(573, 2));
2680 }
2681
2682 #[rstest]
2683 fn test_parse_betfair_ticker_partial_fields() {
2684 let rc = runner_change_with_ticker(
2685 9249757,
2686 Some(Decimal::new(55, 1)),
2687 Some(Decimal::new(189032, 2)),
2688 None,
2689 None,
2690 );
2691 let ts = UnixNanos::from(1_000_000_000u64);
2692 let instrument_id = make_instrument_id("1.185781465", 9249757, Decimal::ZERO);
2693
2694 let ticker = parse_betfair_ticker(instrument_id, &rc, ts, ts).unwrap();
2695
2696 assert_decimal_option_eq(ticker.last_traded_price, Decimal::new(55, 1));
2697 assert_decimal_option_eq(ticker.traded_volume, Decimal::new(189032, 2));
2698 assert!(ticker.starting_price_near.is_none());
2699 assert!(ticker.starting_price_far.is_none());
2700 }
2701
2702 #[rstest]
2703 fn test_parse_betfair_ticker_no_fields_returns_none() {
2704 let rc = runner_change_with_ticker(9249757, None, None, None, None);
2705 let ts = UnixNanos::from(1_000_000_000u64);
2706 let instrument_id = make_instrument_id("1.185781465", 9249757, Decimal::ZERO);
2707
2708 assert!(parse_betfair_ticker(instrument_id, &rc, ts, ts).is_none());
2709 }
2710
2711 #[rstest]
2712 fn test_parse_betfair_ticker_only_tv() {
2713 let rc =
2714 runner_change_with_ticker(40273293, None, Some(Decimal::new(320115, 2)), None, None);
2715 let ts = UnixNanos::from(1_000_000_000u64);
2716 let instrument_id = make_instrument_id("1.185781465", 40273293, Decimal::ZERO);
2717
2718 let ticker = parse_betfair_ticker(instrument_id, &rc, ts, ts).unwrap();
2719
2720 assert!(ticker.last_traded_price.is_none());
2721 assert_decimal_option_eq(ticker.traded_volume, Decimal::new(320115, 2));
2722 assert!(ticker.starting_price_near.is_none());
2723 assert!(ticker.starting_price_far.is_none());
2724 }
2725
2726 #[rstest]
2727 fn test_parse_betfair_ticker_from_fixture() {
2728 let data = load_test_json("stream/mcm_BSP_settled.json");
2729 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2730
2731 if let StreamMessage::MarketChange(mcm) = msg {
2732 let mc = mcm.mc.as_ref().unwrap();
2733 let change = &mc[0];
2734 let rc_list = change.rc.as_ref().unwrap();
2735
2736 let rc = rc_list.iter().find(|r| r.id == 9249757).unwrap();
2738 let instrument_id = make_instrument_id(&change.id, rc.id, Decimal::ZERO);
2739 let ts = parse_millis_timestamp(mcm.pt);
2740
2741 let ticker = parse_betfair_ticker(instrument_id, rc, ts, ts).unwrap();
2742
2743 assert_decimal_option_eq(ticker.last_traded_price, Decimal::new(55, 1));
2744 assert_decimal_option_eq(ticker.traded_volume, Decimal::new(189032, 2));
2745 assert_decimal_option_eq(ticker.starting_price_near, Decimal::new(568, 2));
2746 assert_decimal_option_eq(ticker.starting_price_far, Decimal::new(573, 2));
2747
2748 let rc2 = rc_list.iter().find(|r| r.id == 40273293).unwrap();
2750 let instrument_id2 = make_instrument_id(&change.id, rc2.id, Decimal::ZERO);
2751 let ticker2 = parse_betfair_ticker(instrument_id2, rc2, ts, ts).unwrap();
2752
2753 assert_decimal_option_eq(ticker2.last_traded_price, Decimal::new(21, 1));
2754 assert_decimal_option_eq(ticker2.traded_volume, Decimal::new(320115, 2));
2755 assert!(ticker2.starting_price_near.is_none());
2756 assert!(ticker2.starting_price_far.is_none());
2757
2758 let rc3 = rc_list.iter().find(|r| r.id == 23678734).unwrap();
2760 let instrument_id3 = make_instrument_id(&change.id, rc3.id, Decimal::ZERO);
2761 let ticker3 = parse_betfair_ticker(instrument_id3, rc3, ts, ts).unwrap();
2762
2763 assert!(ticker3.last_traded_price.is_none());
2764 assert_decimal_option_eq(ticker3.traded_volume, Decimal::ZERO);
2765 } else {
2766 panic!("Expected MarketChange");
2767 }
2768 }
2769
2770 #[rstest]
2771 fn test_parse_betfair_starting_prices_from_fixture() {
2772 let data = load_test_json("stream/mcm_BSP_settled.json");
2773 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2774
2775 if let StreamMessage::MarketChange(mcm) = msg {
2776 let mc = mcm.mc.as_ref().unwrap();
2777 let def = mc[0].market_definition.as_ref().unwrap();
2778 let ts = parse_millis_timestamp(mcm.pt);
2779
2780 let prices = parse_betfair_starting_prices(&mc[0].id, def, ts, ts);
2781
2782 assert_eq!(prices.len(), 3);
2784
2785 let bsp_map: std::collections::HashMap<String, Decimal> = prices
2786 .iter()
2787 .map(|p| (p.instrument_id.to_string(), p.bsp))
2788 .collect();
2789
2790 let id_winner = make_instrument_id("1.185781465", 9249757, Decimal::ZERO).to_string();
2791 let id_placed = make_instrument_id("1.185781465", 40273293, Decimal::ZERO).to_string();
2792 let id_loser = make_instrument_id("1.185781465", 11120000, Decimal::ZERO).to_string();
2793
2794 assert_eq!(bsp_map[&id_winner], Decimal::new(573, 2));
2795 assert_eq!(bsp_map[&id_placed], Decimal::new(214, 2));
2796 assert_eq!(bsp_map[&id_loser], Decimal::new(2856, 2));
2797 } else {
2798 panic!("Expected MarketChange");
2799 }
2800 }
2801
2802 #[rstest]
2803 fn test_parse_betfair_starting_prices_no_runners() {
2804 let def = MarketDefinition {
2805 runners: None,
2806 bet_delay: None,
2807 betting_type: None,
2808 bsp_market: None,
2809 bsp_reconciled: None,
2810 competition_id: None,
2811 competition_name: None,
2812 complete: None,
2813 country_code: None,
2814 cross_matching: None,
2815 discount_allowed: None,
2816 each_way_divisor: None,
2817 event_id: None,
2818 event_name: None,
2819 event_type_id: None,
2820 event_type_name: None,
2821 in_play: None,
2822 line_interval: None,
2823 line_max_unit: None,
2824 line_min_unit: None,
2825 market_base_rate: None,
2826 market_id: None,
2827 market_name: None,
2828 market_time: None,
2829 market_type: None,
2830 number_of_active_runners: None,
2831 number_of_winners: None,
2832 open_date: None,
2833 persistence_enabled: None,
2834 price_ladder_definition: None,
2835 race_type: None,
2836 regulators: None,
2837 runners_voidable: None,
2838 settled_time: None,
2839 status: None,
2840 suspend_time: None,
2841 timezone: None,
2842 turn_in_play_enabled: None,
2843 venue: None,
2844 version: None,
2845 };
2846 let ts = UnixNanos::from(1_000_000_000u64);
2847
2848 let prices = parse_betfair_starting_prices("1.12345", &def, ts, ts);
2849
2850 assert!(prices.is_empty());
2851 }
2852
2853 #[rstest]
2854 fn test_parse_bsp_book_deltas_from_fixture() {
2855 let data = load_test_json("stream/mcm_BSP.json");
2856 let messages: Vec<StreamMessage> = serde_json::from_str(&data).unwrap();
2857
2858 let mcm = messages
2860 .iter()
2861 .find_map(|m| match m {
2862 StreamMessage::MarketChange(mcm) => {
2863 let mc = mcm.mc.as_ref()?;
2864 let has_spb = mc.iter().any(|c| {
2865 c.rc.as_ref()
2866 .is_some_and(|rcs| rcs.iter().any(|r| r.spb.is_some()))
2867 });
2868
2869 if has_spb { Some(mcm) } else { None }
2870 }
2871 _ => None,
2872 })
2873 .expect("fixture should contain MCM with spb data");
2874
2875 let mc = mcm.mc.as_ref().unwrap();
2876 let change = &mc[0];
2877 let rc_list = change.rc.as_ref().unwrap();
2878
2879 let rc = rc_list.iter().find(|r| r.id == 9249757).unwrap();
2881 let instrument_id = make_instrument_id(&change.id, rc.id, Decimal::ZERO);
2882 let ts = parse_millis_timestamp(mcm.pt);
2883
2884 let deltas = parse_bsp_book_deltas(instrument_id, rc, ts, ts);
2885
2886 let spb_count = rc.spb.as_ref().unwrap().len();
2887 let spl_count = rc.spl.as_ref().unwrap().len();
2888 assert_eq!(deltas.len(), spb_count + spl_count);
2889
2890 assert_eq!(deltas[0].side, OrderSide::Sell);
2892 assert_eq!(deltas[0].price, Decimal::new(1000, 0));
2893 assert_eq!(deltas[0].size, Decimal::new(3338, 2));
2894 assert_eq!(deltas[0].action, BookAction::Update);
2895
2896 let spl_start = spb_count;
2898 assert_eq!(deltas[spl_start].side, OrderSide::Buy);
2899 assert_eq!(deltas[spl_start].price, Decimal::new(7, 0));
2900 assert_eq!(deltas[spl_start].size, Decimal::new(10, 0));
2901 }
2902
2903 #[rstest]
2904 fn test_parse_bsp_book_deltas_zero_volume_is_delete() {
2905 let rc = RunnerChange {
2906 id: 12345,
2907 hc: None,
2908 atb: None,
2909 atl: None,
2910 batb: None,
2911 batl: None,
2912 bdatb: None,
2913 bdatl: None,
2914 spb: Some(vec![PV {
2915 price: Decimal::new(50, 1),
2916 volume: Decimal::ZERO,
2917 }]),
2918 spl: None,
2919 spn: None,
2920 spf: None,
2921 trd: None,
2922 ltp: None,
2923 tv: None,
2924 };
2925 let ts = UnixNanos::from(1_000_000_000u64);
2926 let instrument_id = make_instrument_id("1.12345", 12345, Decimal::ZERO);
2927
2928 let deltas = parse_bsp_book_deltas(instrument_id, &rc, ts, ts);
2929
2930 assert_eq!(deltas.len(), 1);
2931 assert_eq!(deltas[0].action, BookAction::Delete);
2932 assert_eq!(deltas[0].price, Decimal::new(5, 0));
2933 assert_eq!(deltas[0].size, Decimal::ZERO);
2934 }
2935
2936 #[rstest]
2937 fn test_parse_bsp_book_deltas_no_spb_spl_returns_empty() {
2938 let rc = runner_change_with_ticker(12345, None, None, None, None);
2939 let ts = UnixNanos::from(1_000_000_000u64);
2940 let instrument_id = make_instrument_id("1.12345", 12345, Decimal::ZERO);
2941
2942 let deltas = parse_bsp_book_deltas(instrument_id, &rc, ts, ts);
2943
2944 assert!(deltas.is_empty());
2945 }
2946
2947 #[rstest]
2948 fn test_parse_instrument_closes_from_fixture() {
2949 let data = load_test_json("stream/mcm_BSP_settled.json");
2950 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2951
2952 if let StreamMessage::MarketChange(mcm) = msg {
2953 let mc = mcm.mc.as_ref().unwrap();
2954 let def = mc[0].market_definition.as_ref().unwrap();
2955 let ts = parse_millis_timestamp(mcm.pt);
2956
2957 let closes = parse_instrument_closes(&mc[0].id, def, ts, ts);
2958
2959 assert_eq!(closes.len(), 4);
2961
2962 let close_map: std::collections::HashMap<String, Price> = closes
2963 .iter()
2964 .map(|c| (c.instrument_id.to_string(), c.close_price))
2965 .collect();
2966
2967 let id_winner = make_instrument_id("1.185781465", 9249757, Decimal::ZERO).to_string();
2968 let id_placed = make_instrument_id("1.185781465", 40273293, Decimal::ZERO).to_string();
2969 let id_loser = make_instrument_id("1.185781465", 11120000, Decimal::ZERO).to_string();
2970 let id_removed = make_instrument_id("1.185781465", 37433527, Decimal::ZERO).to_string();
2971
2972 assert_eq!(close_map[&id_winner], Price::from("1.00"));
2973 assert_eq!(close_map[&id_placed], Price::from("1.00"));
2974 assert_eq!(close_map[&id_loser], Price::from("0.00"));
2975 assert_eq!(close_map[&id_removed], Price::from("0.00"));
2976 } else {
2977 panic!("Expected MarketChange");
2978 }
2979 }
2980
2981 #[rstest]
2982 fn test_parse_instrument_closes_active_runners_excluded() {
2983 let data = load_test_json("stream/mcm_BSP.json");
2984 let messages: Vec<StreamMessage> = serde_json::from_str(&data).unwrap();
2985
2986 let mcm = messages
2988 .iter()
2989 .find_map(|m| match m {
2990 StreamMessage::MarketChange(mcm) => {
2991 let mc = mcm.mc.as_ref()?;
2992 mc.iter()
2993 .find(|c| c.market_definition.is_some())
2994 .map(|_| mcm)
2995 }
2996 _ => None,
2997 })
2998 .expect("fixture should contain MCM with market definition");
2999
3000 let mc = mcm.mc.as_ref().unwrap();
3001 let change = mc.iter().find(|c| c.market_definition.is_some()).unwrap();
3002 let def = change.market_definition.as_ref().unwrap();
3003 let ts = parse_millis_timestamp(mcm.pt);
3004
3005 let closes = parse_instrument_closes(&change.id, def, ts, ts);
3006
3007 assert!(
3008 closes.is_empty(),
3009 "Active runners should not produce close events, found {}",
3010 closes.len()
3011 );
3012 }
3013
3014 fn make_test_uo(
3015 bet_id: &str,
3016 size: Decimal,
3017 sm: Option<Decimal>,
3018 avp: Option<Decimal>,
3019 ) -> UnmatchedOrder {
3020 UnmatchedOrder {
3021 id: bet_id.to_string(),
3022 p: Decimal::new(25, 1),
3023 s: size,
3024 side: StreamingSide::Back,
3025 status: StreamingOrderStatus::Executable,
3026 pt: Some(StreamingPersistenceType::Lapse),
3027 ot: StreamingOrderType::Limit,
3028 pd: 1616568581000,
3029 bsp: None,
3030 rfo: None,
3031 rfs: None,
3032 rc: None,
3033 rac: None,
3034 md: None,
3035 cd: None,
3036 ld: None,
3037 avp,
3038 sm,
3039 sr: None,
3040 sl: None,
3041 sc: None,
3042 sv: None,
3043 lsrc: None,
3044 }
3045 }
3046
3047 #[rstest]
3048 fn test_make_trade_id_normalizes_float_tail_sm() {
3049 let uo = make_test_uo(
3050 "430069890490",
3051 Decimal::new(4287, 2),
3052 Some(Decimal::new(4_287_000_000_000_001, 14)),
3053 Some(Decimal::new(25, 1)),
3054 );
3055
3056 let trade_id = make_trade_id(&uo);
3057
3058 assert_eq!(trade_id.as_str(), "430069890490-42.87");
3059 }
3060
3061 #[rstest]
3062 fn test_fill_tracker_sync_order_prevents_duplicate_fill() {
3063 let mut tracker = FillTracker::new();
3064
3065 tracker.sync_order("123456", Decimal::new(10, 0), Decimal::new(25, 1));
3067
3068 let uo = make_test_uo(
3069 "123456",
3070 Decimal::new(20, 0),
3071 Some(Decimal::new(10, 0)),
3072 Some(Decimal::new(25, 1)),
3073 );
3074
3075 let instrument_id = InstrumentId::from("1.234567-123456-0.0.BETFAIR");
3076 let account_id = AccountId::from("BETFAIR-001");
3077 let currency = Currency::from("GBP");
3078 let ts = UnixNanos::default();
3079
3080 let result =
3082 tracker.maybe_fill_report(&uo, uo.s, instrument_id, account_id, currency, ts, ts);
3083 assert!(
3084 result.is_none(),
3085 "should not emit fill for already-synced qty"
3086 );
3087 }
3088
3089 #[rstest]
3090 fn test_fill_tracker_sync_order_is_monotonic() {
3091 let mut tracker = FillTracker::new();
3092
3093 tracker.sync_order("123456", Decimal::new(10, 0), Decimal::new(25, 1));
3095
3096 tracker.sync_order("123456", Decimal::new(5, 0), Decimal::new(20, 1));
3098
3099 let uo = make_test_uo(
3101 "123456",
3102 Decimal::new(20, 0),
3103 Some(Decimal::new(15, 0)),
3104 Some(Decimal::new(25, 1)),
3105 );
3106 let result = tracker.maybe_fill_report(
3107 &uo,
3108 uo.s,
3109 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3110 AccountId::from("BETFAIR-001"),
3111 Currency::from("GBP"),
3112 UnixNanos::default(),
3113 UnixNanos::default(),
3114 );
3115 let fill = result.expect("should emit incremental fill");
3116 assert_eq!(fill.last_qty, Quantity::from("5.00"));
3117 }
3118
3119 #[rstest]
3120 fn test_fill_tracker_sync_order_allows_incremental_fill() {
3121 let mut tracker = FillTracker::new();
3122
3123 tracker.sync_order("123456", Decimal::new(10, 0), Decimal::new(25, 1));
3125
3126 let uo = make_test_uo(
3127 "123456",
3128 Decimal::new(20, 0),
3129 Some(Decimal::new(15, 0)),
3130 Some(Decimal::new(26, 1)),
3131 );
3132
3133 let instrument_id = InstrumentId::from("1.234567-123456-0.0.BETFAIR");
3134 let account_id = AccountId::from("BETFAIR-001");
3135 let currency = Currency::from("GBP");
3136 let ts = UnixNanos::default();
3137
3138 let result =
3140 tracker.maybe_fill_report(&uo, uo.s, instrument_id, account_id, currency, ts, ts);
3141 assert!(result.is_some(), "should emit fill for new matched qty");
3142 let fill = result.unwrap();
3143 assert_eq!(fill.last_qty, Quantity::from("5.00"));
3144 }
3145
3146 #[rstest]
3147 fn test_fill_tracker_seed_published_trade_ids_blocks_replay() {
3148 let mut tracker = FillTracker::new();
3149
3150 let uo_for_id = make_test_uo(
3151 "123456",
3152 Decimal::new(20, 0),
3153 Some(Decimal::new(10, 0)),
3154 Some(Decimal::new(25, 1)),
3155 );
3156 let trade_id = make_trade_id(&uo_for_id);
3157
3158 tracker.seed_published_trade_ids([trade_id.to_string()]);
3161
3162 let result = tracker.maybe_fill_report(
3163 &uo_for_id,
3164 uo_for_id.s,
3165 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3166 AccountId::from("BETFAIR-001"),
3167 Currency::from("GBP"),
3168 UnixNanos::default(),
3169 UnixNanos::default(),
3170 );
3171
3172 assert!(
3173 result.is_none(),
3174 "seeded trade-id should suppress duplicate fill",
3175 );
3176
3177 let next_update = make_test_uo(
3178 "123456",
3179 Decimal::new(20, 0),
3180 Some(Decimal::new(15, 0)),
3181 Some(Decimal::new(25, 1)),
3182 );
3183 let next_fill = tracker
3184 .maybe_fill_report(
3185 &next_update,
3186 next_update.s,
3187 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3188 AccountId::from("BETFAIR-001"),
3189 Currency::from("GBP"),
3190 UnixNanos::default(),
3191 UnixNanos::default(),
3192 )
3193 .expect("later cumulative state should emit only the new delta");
3194 assert_eq!(next_fill.last_qty, Quantity::from("5.00"));
3195 }
3196
3197 #[rstest]
3198 fn test_fill_tracker_accepts_sm_float_tail_at_order_quantity() {
3199 let mut tracker = FillTracker::new();
3200 let uo = make_test_uo(
3201 "430069890490",
3202 Decimal::new(4287, 2),
3203 Some(Decimal::new(4_287_000_000_000_001, 14)),
3204 Some(Decimal::new(25, 1)),
3205 );
3206
3207 let result = tracker.maybe_fill_report(
3208 &uo,
3209 uo.s,
3210 InstrumentId::from("1.234567-430069890490-0.0.BETFAIR"),
3211 AccountId::from("BETFAIR-001"),
3212 Currency::from("GBP"),
3213 UnixNanos::default(),
3214 UnixNanos::default(),
3215 );
3216
3217 let fill = result.expect("float tail at order quantity should emit fill");
3218 assert_eq!(fill.last_qty, Quantity::from("42.87"));
3219 assert_eq!(fill.trade_id.as_str(), "430069890490-42.87");
3220
3221 let duplicate = tracker.maybe_fill_report(
3222 &uo,
3223 uo.s,
3224 InstrumentId::from("1.234567-430069890490-0.0.BETFAIR"),
3225 AccountId::from("BETFAIR-001"),
3226 Currency::from("GBP"),
3227 UnixNanos::default(),
3228 UnixNanos::default(),
3229 );
3230 assert!(
3231 duplicate.is_none(),
3232 "same normalized sm should not emit a duplicate fill"
3233 );
3234 }
3235
3236 #[rstest]
3237 fn test_fill_tracker_normalized_duplicate_updates_average_price_anchor() {
3238 let mut tracker = FillTracker::new();
3239
3240 let first = tracker.advance_cumulative_fill(
3241 "123456",
3242 Decimal::new(10, 0),
3243 Some(Decimal::new(20, 1)),
3244 Decimal::new(20, 1),
3245 );
3246 let normalized_duplicate = tracker.advance_cumulative_fill(
3247 "123456",
3248 Decimal::new(10001, 3),
3249 Some(Decimal::new(30, 1)),
3250 Decimal::new(30, 1),
3251 );
3252 let next = tracker
3253 .advance_cumulative_fill(
3254 "123456",
3255 Decimal::new(11, 0),
3256 Some(Decimal::new(30, 1)),
3257 Decimal::new(30, 1),
3258 )
3259 .expect("new cumulative quantity should emit a fill");
3260
3261 let first = first.expect("first fill");
3262 let restatement = normalized_duplicate.expect("changed average restates the surviving lot");
3263 assert_eq!(restatement.0, first.0);
3264 assert_eq!(restatement.1, Quantity::from("10.00"));
3265 assert_eq!(restatement.2, Price::from("3.00"));
3266 assert_eq!(next.1, Quantity::from("1.00"));
3267 assert_eq!(next.2, Price::from("3.00"));
3268 }
3269
3270 #[rstest]
3271 fn test_fill_tracker_changed_average_with_two_lots_emits_nothing() {
3272 let mut tracker = FillTracker::new();
3273 let first = tracker
3274 .advance_cumulative_fill(
3275 "bet",
3276 Decimal::from(2),
3277 Some(Decimal::from(12)),
3278 Decimal::from(12),
3279 )
3280 .expect("first lot");
3281 let second = tracker
3282 .advance_cumulative_fill(
3283 "bet",
3284 Decimal::from(4),
3285 Some(Decimal::from(10)),
3286 Decimal::from(10),
3287 )
3288 .expect("second lot");
3289 let restatement = tracker.advance_cumulative_fill(
3290 "bet",
3291 Decimal::from(4),
3292 Some(Decimal::new(900, 2)),
3293 Decimal::from(12),
3294 );
3295 let later = tracker
3296 .advance_cumulative_fill(
3297 "bet",
3298 Decimal::from(6),
3299 Some(Decimal::from(8)),
3300 Decimal::from(12),
3301 )
3302 .expect("later fill uses the corrected average");
3303
3304 assert_ne!(first.0, second.0);
3305 assert!(restatement.is_none());
3306 assert_eq!(later.1, Quantity::from("2.00"));
3308 assert_eq!(later.2, Price::from("6.00"));
3309 }
3310
3311 #[rstest]
3312 fn test_fill_tracker_void_with_new_average_does_not_restate_price() {
3313 let mut tracker = FillTracker::new();
3314 tracker
3315 .advance_cumulative_fill(
3316 "bet",
3317 Decimal::from(2),
3318 Some(Decimal::from(12)),
3319 Decimal::from(12),
3320 )
3321 .expect("fill");
3322 let restatement = tracker.advance_cumulative_fill_with_voids(
3323 "bet",
3324 Decimal::from(2),
3325 Decimal::from(1),
3326 Some(Decimal::new(947, 2)),
3327 Decimal::from(12),
3328 );
3329
3330 assert!(restatement.is_none());
3331 }
3332
3333 #[rstest]
3334 fn test_fill_tracker_post_void_fill_uses_restated_accounting_price() {
3335 let mut tracker = FillTracker::new();
3336 let bet_id = "bet-void-restate";
3337 tracker
3338 .advance_cumulative_fill(
3339 bet_id,
3340 Decimal::from(2),
3341 Some(Decimal::from(12)),
3342 Decimal::from(12),
3343 )
3344 .expect("fill");
3345
3346 let voided = tracker.maybe_fill_voids(&UnmatchedOrder {
3347 id: bet_id.to_string(),
3348 sv: Some(Decimal::from(1)),
3349 ..make_test_uo(bet_id, Decimal::from(2), Some(Decimal::from(1)), None)
3350 });
3351
3352 let restatement = tracker
3353 .advance_cumulative_fill_with_voids(
3354 bet_id,
3355 Decimal::from(2),
3356 Decimal::from(1),
3357 Some(Decimal::new(947, 2)),
3358 Decimal::from(12),
3359 )
3360 .expect("one surviving lot restates");
3361 let later = tracker
3362 .advance_cumulative_fill_with_voids(
3363 bet_id,
3364 Decimal::from(3),
3365 Decimal::from(1),
3366 Some(Decimal::from(10)),
3367 Decimal::from(12),
3368 )
3369 .expect("later fill");
3370
3371 assert_eq!(voided[0].last_px, Price::from("12.00"));
3372 assert_eq!(restatement.2, Price::from("9.47"));
3373 assert_eq!(later.2, Price::from("10.53"));
3374 }
3375
3376 #[rstest]
3377 fn test_fill_tracker_overfill_rejected() {
3378 let mut tracker = FillTracker::new();
3379
3380 let uo = make_test_uo(
3382 "999001",
3383 Decimal::new(20, 0),
3384 Some(Decimal::new(30, 0)),
3385 Some(Decimal::new(25, 1)),
3386 );
3387
3388 let instrument_id = InstrumentId::from("1.234567-999001-0.0.BETFAIR");
3389 let account_id = AccountId::from("BETFAIR-001");
3390 let currency = Currency::from("GBP");
3391 let ts = UnixNanos::default();
3392
3393 let result =
3394 tracker.maybe_fill_report(&uo, uo.s, instrument_id, account_id, currency, ts, ts);
3395 assert!(
3396 result.is_none(),
3397 "overfill (sm > order_qty) should be rejected"
3398 );
3399 }
3400
3401 #[rstest]
3402 fn test_fill_tracker_zero_sm_returns_none() {
3403 let mut tracker = FillTracker::new();
3404
3405 let uo = make_test_uo("999002", Decimal::new(10, 0), Some(Decimal::ZERO), None);
3406
3407 let instrument_id = InstrumentId::from("1.234567-999002-0.0.BETFAIR");
3408 let result = tracker.maybe_fill_report(
3409 &uo,
3410 uo.s,
3411 instrument_id,
3412 AccountId::from("BETFAIR-001"),
3413 Currency::from("GBP"),
3414 UnixNanos::default(),
3415 UnixNanos::default(),
3416 );
3417 assert!(result.is_none(), "zero sm should not produce a fill");
3418 }
3419
3420 #[rstest]
3421 fn test_fill_tracker_no_avp_uses_order_price() {
3422 let data = load_test_json("stream/ocm_FILLED_no_avp.json");
3423 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
3424
3425 if let StreamMessage::OrderChange(ocm) = msg {
3426 let oc = ocm.oc.as_ref().unwrap();
3427 let omc = &oc[0];
3428 let orc = &omc.orc.as_ref().unwrap()[0];
3429 let uo = &orc.uo.as_ref().unwrap()[0];
3430 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
3431 let ts = parse_millis_timestamp(ocm.pt);
3432
3433 let mut tracker = FillTracker::new();
3434 let fill = tracker
3435 .maybe_fill_report(
3436 uo,
3437 uo.s,
3438 instrument_id,
3439 AccountId::from("BETFAIR-001"),
3440 Currency::GBP(),
3441 ts,
3442 ts,
3443 )
3444 .expect("should produce fill even without avp");
3445
3446 assert_eq!(fill.last_qty.as_f64(), 25.0);
3448 assert_eq!(fill.last_px.as_f64(), 3.5);
3449 } else {
3450 panic!("expected OrderChange");
3451 }
3452 }
3453
3454 #[rstest]
3455 fn test_fill_tracker_weighted_avg_back_calculation() {
3456 let mut tracker = FillTracker::new();
3457 let instrument_id = InstrumentId::from("1.234567-999003-0.0.BETFAIR");
3458 let account_id = AccountId::from("BETFAIR-001");
3459 let currency = Currency::from("GBP");
3460 let ts = UnixNanos::default();
3461
3462 let uo1 = make_test_uo(
3464 "999003",
3465 Decimal::new(30, 0),
3466 Some(Decimal::new(10, 0)),
3467 Some(Decimal::new(20, 1)),
3468 );
3469 let fill1 = tracker
3470 .maybe_fill_report(&uo1, uo1.s, instrument_id, account_id, currency, ts, ts)
3471 .expect("first fill");
3472 assert_eq!(fill1.last_px.as_f64(), 2.0);
3473 assert_eq!(fill1.last_qty.as_f64(), 10.0);
3474
3475 let uo2 = make_test_uo(
3478 "999003",
3479 Decimal::new(30, 0),
3480 Some(Decimal::new(20, 0)),
3481 Some(Decimal::new(25, 1)),
3482 );
3483 let fill2 = tracker
3484 .maybe_fill_report(&uo2, uo2.s, instrument_id, account_id, currency, ts, ts)
3485 .expect("second fill");
3486 assert_eq!(fill2.last_qty.as_f64(), 10.0);
3487 assert_eq!(fill2.last_px.as_f64(), 3.0);
3488 }
3489
3490 #[rstest]
3491 fn test_fill_tracker_negative_fill_price_falls_back_to_avp() {
3492 let mut tracker = FillTracker::new();
3493 let instrument_id = InstrumentId::from("1.234567-999004-0.0.BETFAIR");
3494 let account_id = AccountId::from("BETFAIR-001");
3495 let currency = Currency::from("GBP");
3496 let ts = UnixNanos::default();
3497
3498 let uo1 = make_test_uo(
3500 "999004",
3501 Decimal::new(20, 0),
3502 Some(Decimal::new(10, 0)),
3503 Some(Decimal::new(50, 1)),
3504 );
3505 tracker
3506 .maybe_fill_report(&uo1, uo1.s, instrument_id, account_id, currency, ts, ts)
3507 .expect("first fill");
3508
3509 let uo2 = make_test_uo(
3513 "999004",
3514 Decimal::new(20, 0),
3515 Some(Decimal::new(15, 0)),
3516 Some(Decimal::new(10, 1)),
3517 );
3518 let fill2 = tracker
3519 .maybe_fill_report(&uo2, uo2.s, instrument_id, account_id, currency, ts, ts)
3520 .expect("second fill should use avp fallback");
3521 assert_eq!(fill2.last_qty.as_f64(), 5.0);
3522 assert_eq!(fill2.last_px.as_f64(), 1.0);
3523 }
3524
3525 #[rstest]
3526 fn test_fill_tracker_prune_clears_state() {
3527 let mut tracker = FillTracker::new();
3528 let instrument_id = InstrumentId::from("1.234567-999005-0.0.BETFAIR");
3529 let account_id = AccountId::from("BETFAIR-001");
3530 let currency = Currency::from("GBP");
3531 let ts = UnixNanos::default();
3532
3533 let uo = make_test_uo(
3535 "999005",
3536 Decimal::new(10, 0),
3537 Some(Decimal::new(10, 0)),
3538 Some(Decimal::new(25, 1)),
3539 );
3540 let fill1 =
3541 tracker.maybe_fill_report(&uo, uo.s, instrument_id, account_id, currency, ts, ts);
3542 assert!(fill1.is_some());
3543
3544 let fill2 =
3546 tracker.maybe_fill_report(&uo, uo.s, instrument_id, account_id, currency, ts, ts);
3547 assert!(fill2.is_none(), "should be deduplicated");
3548
3549 tracker.prune("999005");
3551
3552 let fill3 =
3554 tracker.maybe_fill_report(&uo, uo.s, instrument_id, account_id, currency, ts, ts);
3555 assert!(fill3.is_some(), "after prune, should produce fill again");
3556 }
3557
3558 #[rstest]
3559 fn test_fill_tracker_sm_none_returns_none() {
3560 let mut tracker = FillTracker::new();
3561
3562 let uo = make_test_uo("999006", Decimal::new(10, 0), None, None);
3564
3565 let instrument_id = InstrumentId::from("1.234567-999006-0.0.BETFAIR");
3566 let result = tracker.maybe_fill_report(
3567 &uo,
3568 uo.s,
3569 instrument_id,
3570 AccountId::from("BETFAIR-001"),
3571 Currency::from("GBP"),
3572 UnixNanos::default(),
3573 UnixNanos::default(),
3574 );
3575 assert!(result.is_none(), "None sm should not produce a fill");
3576 }
3577
3578 #[rstest]
3579 fn test_parse_order_status_report_missing_persistence_type_for_market_on_close() {
3580 let uo = UnmatchedOrder {
3581 s: Decimal::ZERO,
3582 pt: None,
3583 ot: StreamingOrderType::MarketOnClose,
3584 sr: Some(Decimal::new(10, 0)),
3585 ..make_test_uo("999007", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3586 };
3587
3588 let report = parse_order_status_report(
3589 &uo,
3590 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3591 AccountId::from("BETFAIR-001"),
3592 UnixNanos::default(),
3593 UnixNanos::default(),
3594 )
3595 .unwrap();
3596
3597 assert_eq!(report.quantity, Quantity::from("10.00"));
3598 assert_eq!(report.time_in_force, TimeInForce::AtTheClose);
3599 }
3600
3601 #[rstest]
3602 fn test_parse_order_status_report_missing_persistence_type_for_limit_on_close() {
3603 let uo = UnmatchedOrder {
3604 s: Decimal::ZERO,
3605 pt: None,
3606 ot: StreamingOrderType::LimitOnClose,
3607 sr: Some(Decimal::new(10, 0)),
3608 ..make_test_uo("999013", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3609 };
3610
3611 let report = parse_order_status_report(
3612 &uo,
3613 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3614 AccountId::from("BETFAIR-001"),
3615 UnixNanos::default(),
3616 UnixNanos::default(),
3617 )
3618 .unwrap();
3619
3620 assert_eq!(report.quantity, Quantity::from("10.00"));
3621 assert_eq!(report.time_in_force, TimeInForce::AtTheClose);
3622 }
3623
3624 #[rstest]
3625 fn test_parse_order_status_report_market_on_close_uses_bsp_liability() {
3626 let uo = UnmatchedOrder {
3627 s: Decimal::ZERO,
3628 bsp: Some(Decimal::new(20, 1)),
3629 pt: None,
3630 ot: StreamingOrderType::MarketOnClose,
3631 ..make_test_uo("999010", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3632 };
3633
3634 let report = parse_order_status_report(
3635 &uo,
3636 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3637 AccountId::from("BETFAIR-001"),
3638 UnixNanos::default(),
3639 UnixNanos::default(),
3640 )
3641 .unwrap();
3642
3643 assert_eq!(report.quantity, Quantity::from("2.00"));
3644 assert_eq!(report.time_in_force, TimeInForce::AtTheClose);
3645 }
3646
3647 #[rstest]
3648 fn test_parse_order_status_report_fails_for_non_positive_quantity() {
3649 let uo = UnmatchedOrder {
3650 s: Decimal::ZERO,
3651 sm: Some(Decimal::ZERO),
3652 sr: Some(Decimal::ZERO),
3653 sc: Some(Decimal::ZERO),
3654 sl: Some(Decimal::ZERO),
3655 sv: Some(Decimal::ZERO),
3656 ..make_test_uo("999014", Decimal::ZERO, Some(Decimal::ZERO), None)
3657 };
3658
3659 let result = parse_order_status_report(
3660 &uo,
3661 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3662 AccountId::from("BETFAIR-001"),
3663 UnixNanos::default(),
3664 UnixNanos::default(),
3665 );
3666
3667 assert!(result.is_err());
3668 assert!(
3669 result
3670 .unwrap_err()
3671 .to_string()
3672 .contains("failed to resolve positive quantity for stream order update 999014")
3673 );
3674 }
3675
3676 #[rstest]
3677 fn test_parse_order_status_report_includes_lapse_reason() {
3678 let uo = UnmatchedOrder {
3679 status: StreamingOrderStatus::ExecutionComplete,
3680 sl: Some(Decimal::ONE),
3681 lsrc: Some(crate::common::enums::LapseStatusReasonCode::SpInPlay),
3682 ..make_test_uo("999012", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3683 };
3684
3685 let report = parse_order_status_report(
3686 &uo,
3687 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3688 AccountId::from("BETFAIR-001"),
3689 UnixNanos::default(),
3690 UnixNanos::default(),
3691 )
3692 .unwrap();
3693
3694 assert_eq!(report.order_status, OrderStatus::Canceled);
3695 assert_eq!(report.cancel_reason.as_deref(), Some("SP_IN_PLAY"));
3696 }
3697
3698 #[rstest]
3699 fn test_parse_order_status_report_blank_rfo_normalizes_to_none() {
3700 let uo = UnmatchedOrder {
3703 rfo: Some(String::new()),
3704 ..make_test_uo("999013", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3705 };
3706
3707 let report = parse_order_status_report(
3708 &uo,
3709 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3710 AccountId::from("BETFAIR-001"),
3711 UnixNanos::default(),
3712 UnixNanos::default(),
3713 )
3714 .unwrap();
3715
3716 assert!(report.client_order_id.is_none());
3717 }
3718
3719 #[rstest]
3720 fn test_fill_tracker_blank_rfo_normalizes_to_none() {
3721 let mut tracker = FillTracker::new();
3722 let uo = UnmatchedOrder {
3723 rfo: Some(String::new()),
3724 sm: Some(Decimal::new(5, 0)),
3725 avp: Some(Decimal::new(25, 1)),
3726 ..make_test_uo("999015", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3727 };
3728
3729 let fill = tracker
3730 .maybe_fill_report(
3731 &uo,
3732 uo.s,
3733 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3734 AccountId::from("BETFAIR-001"),
3735 Currency::from("GBP"),
3736 UnixNanos::default(),
3737 UnixNanos::default(),
3738 )
3739 .expect("blank rfo should still produce a fill");
3740
3741 assert!(fill.client_order_id.is_none());
3742 }
3743
3744 #[rstest]
3745 fn test_fill_tracker_first_seen_void_records_without_correction() {
3746 let mut tracker = FillTracker::new();
3747 let uo = UnmatchedOrder {
3748 status: StreamingOrderStatus::ExecutionComplete,
3749 sm: Some(Decimal::new(50, 0)),
3750 sv: Some(Decimal::new(50, 0)),
3751 ..make_test_uo("999016", Decimal::new(50, 0), None, None)
3752 };
3753
3754 let first = tracker.maybe_fill_voids(&uo);
3755 let duplicate = tracker.maybe_fill_voids(&uo);
3756
3757 assert!(first.is_empty());
3758 assert!(duplicate.is_empty());
3759 assert!(!tracker.has_unseen_fill_void(&uo));
3760 }
3761
3762 #[rstest]
3763 fn test_fill_tracker_emits_only_increased_cumulative_void() {
3764 let mut tracker = FillTracker::new();
3765 let instrument_id = InstrumentId::from("1.234567-123456-0.0.BETFAIR");
3766 let account_id = AccountId::from("BETFAIR-001");
3767 let mut uo = make_test_uo(
3768 "999017",
3769 Decimal::new(60, 0),
3770 Some(Decimal::new(60, 0)),
3771 Some(Decimal::new(25, 1)),
3772 );
3773 tracker
3774 .maybe_fill_report(
3775 &uo,
3776 uo.s,
3777 instrument_id,
3778 account_id,
3779 Currency::GBP(),
3780 UnixNanos::default(),
3781 UnixNanos::default(),
3782 )
3783 .expect("matched size should establish a fill lot");
3784
3785 uo.sv = Some(Decimal::new(40, 0));
3786 let first = tracker.maybe_fill_voids(&uo);
3787 let duplicate = tracker.maybe_fill_voids(&uo);
3788 uo.sv = Some(Decimal::new(50, 0));
3789 let unseen_before_update = tracker.has_unseen_fill_void(&uo);
3790 let increased = tracker.maybe_fill_voids(&uo);
3791
3792 assert_eq!(first.len(), 1);
3793 assert_eq!(first[0].voided_qty, Quantity::from("40.00"));
3794 assert!(duplicate.is_empty());
3795 assert!(unseen_before_update);
3796 assert_eq!(increased.len(), 1);
3797 assert_eq!(increased[0].trade_id, first[0].trade_id);
3798 assert_eq!(increased[0].voided_qty, Quantity::from("50.00"));
3799 assert!(!tracker.has_unseen_fill_void(&uo));
3800 }
3801
3802 #[rstest]
3803 fn test_fill_tracker_allocates_cumulative_void_to_newest_fill_lot_first() {
3804 let mut tracker = FillTracker::new();
3805 let bet_id = "999019";
3806 let older_trade_id = TradeId::from("999019-30.00");
3807 let newer_trade_id = TradeId::from("999019-100.00");
3808 tracker.sync_fill_lot(
3809 bet_id,
3810 older_trade_id,
3811 Decimal::new(30, 0),
3812 Price::from("2.00"),
3813 Decimal::ZERO,
3814 );
3815 tracker.sync_fill_lot(
3816 bet_id,
3817 newer_trade_id,
3818 Decimal::new(70, 0),
3819 Price::from("3.00"),
3820 Decimal::ZERO,
3821 );
3822 let uo = UnmatchedOrder {
3823 sv: Some(Decimal::new(50, 0)),
3824 ..make_test_uo(bet_id, Decimal::new(100, 0), None, None)
3825 };
3826
3827 let corrections = tracker.maybe_fill_voids(&uo);
3828
3829 assert_eq!(corrections.len(), 1);
3830 assert_eq!(corrections[0].trade_id, newer_trade_id);
3831 assert_eq!(corrections[0].voided_qty, Quantity::from("50.00"));
3832 assert_eq!(corrections[0].last_px, Price::from("3.00"));
3833 }
3834
3835 #[rstest]
3836 fn test_fill_tracker_prices_new_fill_from_post_void_average() {
3837 let mut tracker = FillTracker::new();
3838 let bet_id = "999021";
3839 let older_trade_id = TradeId::from("999021-50.00");
3840 tracker.sync_fill_lot(
3841 bet_id,
3842 older_trade_id,
3843 Decimal::new(50, 0),
3844 Price::from("2.00"),
3845 Decimal::ZERO,
3846 );
3847 let (_, last_qty, last_px) = tracker
3848 .advance_cumulative_fill_with_voids(
3849 bet_id,
3850 Decimal::new(100, 0),
3851 Decimal::new(40, 0),
3852 Some(Decimal::new(25, 1)),
3853 Decimal::new(20, 1),
3854 )
3855 .expect("gross lifecycle increase should produce a fill");
3856
3857 let uo = UnmatchedOrder {
3858 sm: Some(Decimal::new(60, 0)),
3859 sv: Some(Decimal::new(40, 0)),
3860 ..make_test_uo(bet_id, Decimal::new(100, 0), None, None)
3861 };
3862 let corrections = tracker.maybe_fill_voids(&uo);
3863
3864 assert_eq!(last_qty, Quantity::from("50.00"));
3865 assert_eq!(last_px, Price::from("5.00"));
3866 assert_eq!(corrections.len(), 1);
3867 assert_eq!(corrections[0].voided_qty, Quantity::from("40.00"));
3868 assert_eq!(corrections[0].last_px, Price::from("5.00"));
3869 }
3870
3871 #[rstest]
3872 fn test_fill_tracker_preserves_prior_void_allocation_when_new_fill_arrives() {
3873 let mut tracker = FillTracker::new();
3874 let bet_id = "999020";
3875 let older_trade_id = TradeId::from("999020-60.00");
3876 let newer_trade_id = TradeId::from("999020-80.00");
3877 tracker.sync_fill_lot(
3878 bet_id,
3879 older_trade_id,
3880 Decimal::new(60, 0),
3881 Price::from("2.00"),
3882 Decimal::ZERO,
3883 );
3884 let mut uo = UnmatchedOrder {
3885 sv: Some(Decimal::new(40, 0)),
3886 ..make_test_uo(bet_id, Decimal::new(80, 0), None, None)
3887 };
3888
3889 let first = tracker.maybe_fill_voids(&uo);
3890 tracker.sync_fill_lot(
3891 bet_id,
3892 newer_trade_id,
3893 Decimal::new(20, 0),
3894 Price::from("3.00"),
3895 Decimal::ZERO,
3896 );
3897 uo.sv = Some(Decimal::new(50, 0));
3898 let increased = tracker.maybe_fill_voids(&uo);
3899
3900 assert_eq!(first.len(), 1);
3901 assert_eq!(first[0].trade_id, older_trade_id);
3902 assert_eq!(first[0].voided_qty, Quantity::from("40.00"));
3903 assert_eq!(increased.len(), 1);
3904 assert_eq!(increased[0].trade_id, newer_trade_id);
3905 assert_eq!(increased[0].voided_qty, Quantity::from("10.00"));
3906 }
3907
3908 #[rstest]
3909 fn test_fill_tracker_reconnect_increased_void_does_not_replay_gross_fill() {
3910 let mut tracker = FillTracker::new();
3911 let instrument_id = InstrumentId::from("1.234567-123456-0.0.BETFAIR");
3912 let account_id = AccountId::from("BETFAIR-001");
3913 let mut uo = make_test_uo(
3914 "999018",
3915 Decimal::new(60, 0),
3916 Some(Decimal::new(60, 0)),
3917 Some(Decimal::new(25, 1)),
3918 );
3919 let trade_id = make_trade_id(&uo);
3920 tracker.sync_fill_lot(
3921 &uo.id,
3922 trade_id,
3923 Decimal::new(60, 0),
3924 Price::from("2.50"),
3925 Decimal::new(40, 0),
3926 );
3927 tracker.sync_voided_qty(&uo.id, Decimal::new(40, 0));
3928 uo.sv = Some(Decimal::new(50, 0));
3929
3930 let fill = tracker.maybe_fill_report(
3931 &uo,
3932 uo.s,
3933 instrument_id,
3934 account_id,
3935 Currency::GBP(),
3936 UnixNanos::default(),
3937 UnixNanos::default(),
3938 );
3939 let corrections = tracker.maybe_fill_voids(&uo);
3940
3941 assert!(fill.is_none());
3942 assert_eq!(corrections.len(), 1);
3943 assert_eq!(corrections[0].trade_id, trade_id);
3944 assert_eq!(corrections[0].voided_qty, Quantity::from("50.00"));
3945 }
3946
3947 #[rstest]
3948 fn test_parse_order_status_report_missing_persistence_type_fails_for_limit_order() {
3949 let uo = UnmatchedOrder {
3950 pt: None,
3951 ..make_test_uo("999008", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3952 };
3953
3954 let result = parse_order_status_report(
3955 &uo,
3956 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3957 AccountId::from("BETFAIR-001"),
3958 UnixNanos::default(),
3959 UnixNanos::default(),
3960 );
3961
3962 assert!(result.is_err());
3963 assert_eq!(
3964 result.unwrap_err().to_string(),
3965 "missing persistence type for order update 999008"
3966 );
3967 }
3968
3969 #[rstest]
3970 fn test_fill_tracker_uses_lifecycle_quantity_when_stream_size_is_zero() {
3971 let mut tracker = FillTracker::new();
3972 let uo = UnmatchedOrder {
3973 s: Decimal::ZERO,
3974 sr: Some(Decimal::new(10, 0)),
3975 sm: Some(Decimal::new(5, 0)),
3976 avp: Some(Decimal::new(20, 1)),
3977 ..make_test_uo("999009", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3978 };
3979
3980 let fill = tracker
3981 .maybe_fill_report(
3982 &uo,
3983 uo.s,
3984 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3985 AccountId::from("BETFAIR-001"),
3986 Currency::from("GBP"),
3987 UnixNanos::default(),
3988 UnixNanos::default(),
3989 )
3990 .expect("zero stream size should fall back to lifecycle quantities");
3991
3992 assert_eq!(fill.last_qty, Quantity::from("5.00"));
3993 }
3994
3995 #[rstest]
3996 fn test_fill_tracker_uses_bsp_liability_when_stream_size_is_zero() {
3997 let mut tracker = FillTracker::new();
3998 let uo = UnmatchedOrder {
3999 s: Decimal::ZERO,
4000 bsp: Some(Decimal::new(20, 1)),
4001 pt: None,
4002 ot: StreamingOrderType::MarketOnClose,
4003 sm: Some(Decimal::new(10, 1)),
4004 avp: Some(Decimal::new(20, 1)),
4005 ..make_test_uo("999011", Decimal::new(10, 0), Some(Decimal::ZERO), None)
4006 };
4007
4008 let fill = tracker
4009 .maybe_fill_report(
4010 &uo,
4011 uo.s,
4012 InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
4013 AccountId::from("BETFAIR-001"),
4014 Currency::from("GBP"),
4015 UnixNanos::default(),
4016 UnixNanos::default(),
4017 )
4018 .expect("zero stream size should fall back to bsp liability");
4019
4020 assert_eq!(fill.last_qty, Quantity::from("1.00"));
4021 }
4022
4023 #[rstest]
4024 fn test_fill_tracker_partial_void_still_emits_fill() {
4025 let data = load_test_json("stream/ocm_VOIDED_partial.json");
4026 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
4027
4028 if let StreamMessage::OrderChange(ocm) = msg {
4029 let oc = ocm.oc.as_ref().unwrap();
4030 let omc = &oc[0];
4031 let orc = &omc.orc.as_ref().unwrap()[0];
4032 let uo = &orc.uo.as_ref().unwrap()[0];
4033 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
4034 let ts = parse_millis_timestamp(ocm.pt);
4035
4036 let mut tracker = FillTracker::new();
4037 let fill = tracker
4038 .maybe_fill_report(
4039 uo,
4040 uo.s,
4041 instrument_id,
4042 AccountId::from("BETFAIR-001"),
4043 Currency::GBP(),
4044 ts,
4045 ts,
4046 )
4047 .expect("should produce fill for matched portion");
4048
4049 assert_eq!(fill.last_qty.as_f64(), 60.0);
4051 assert_eq!(fill.last_px.as_f64(), 1.5);
4052 assert_eq!(fill.order_side, OrderSide::Sell);
4053
4054 let report = parse_order_status_report(
4055 uo,
4056 instrument_id,
4057 AccountId::from("BETFAIR-001"),
4058 ts,
4059 ts,
4060 )
4061 .unwrap();
4062 assert_eq!(report.filled_qty, Quantity::from("60.00"));
4063 } else {
4064 panic!("expected OrderChange");
4065 }
4066 }
4067
4068 #[rstest]
4069 fn test_fill_tracker_no_fill_when_sv_zero_and_fully_filled() {
4070 let data = load_test_json("stream/ocm_FILLED_sv_zero.json");
4071 let msg: StreamMessage = serde_json::from_str(&data).unwrap();
4072
4073 if let StreamMessage::OrderChange(ocm) = msg {
4074 let oc = ocm.oc.as_ref().unwrap();
4075 let omc = &oc[0];
4076 let orc = &omc.orc.as_ref().unwrap()[0];
4077 let uo = &orc.uo.as_ref().unwrap()[0];
4078 let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
4079 let ts = parse_millis_timestamp(ocm.pt);
4080
4081 let mut tracker = FillTracker::new();
4082 let fill = tracker
4083 .maybe_fill_report(
4084 uo,
4085 uo.s,
4086 instrument_id,
4087 AccountId::from("BETFAIR-001"),
4088 Currency::GBP(),
4089 ts,
4090 ts,
4091 )
4092 .expect("fully filled order should produce fill");
4093
4094 assert_eq!(fill.last_qty.as_f64(), 50.0);
4095 assert_eq!(fill.last_px.as_f64(), 2.0);
4096
4097 assert_eq!(uo.sv, Some(Decimal::ZERO));
4099 } else {
4100 panic!("expected OrderChange");
4101 }
4102 }
4103}