1use std::{
29 cell::{Ref, RefCell},
30 fmt::Debug,
31 rc::Rc,
32 sync::LazyLock,
33 time::Duration,
34};
35
36use anyhow::Context;
37use indexmap::{IndexMap, IndexSet};
38use nautilus_common::{
39 cache::{Cache, refs::PositionRef},
40 clients::{DEFAULT_POSITION_RECONCILIATION_TOLERANCE, ExecutionClient},
41 clock::Clock,
42 config::ConfigResult,
43 enums::{LogColor, LogLevel},
44 live::dst,
45 log_info,
46 messages::{
47 ExecutionReport,
48 execution::{
49 QueryOrder, TradingCommand,
50 report::{
51 GenerateFillReports, GenerateOrderStatusReport, GenerateOrderStatusReports,
52 GeneratePositionStatusReports,
53 },
54 },
55 },
56 msgbus::{self, MessagingSwitchboard, switchboard},
57};
58use nautilus_core::{DurationNanos, UUID4, UnixNanos, datetime::mins_to_secs};
59use nautilus_execution::{
60 engine::ExecutionEngine,
61 reconciliation::{
62 RECONCILIATION_ORDER_TAG, ReconciliationResult as AdjustedReports,
63 calculate_reconciliation_price, create_inferred_fill_for_qty,
64 create_reconciliation_rejected, create_reconciliation_triggered,
65 fill_precedes_snapshot_reconciled_position,
66 generate_external_order_status_events_with_commission,
67 generate_reconciliation_order_pre_fill_events,
68 generate_reconciliation_order_snapshot_events_with_commission,
69 incremental_inferred_fill_price_and_liquidity, inferred_fill_price_and_liquidity,
70 position_prices_match, process_mass_status_for_reconciliation,
71 process_mass_status_for_reconciliation_without_synthetic_reports,
72 reconcile_order_report_with_commission, should_reconciliation_update,
73 },
74};
75use nautilus_model::{
76 enums::{AvgPxReconciliation, OmsType, OrderSide, OrderStatus},
77 events::{OrderEventAny, OrderFilled, OrderInitialized, OrderUpdated},
78 identifiers::{
79 AccountId, ClientId, ClientOrderId, InstrumentId, PositionId, StrategyId, TradeId,
80 TraderId, VenueOrderId,
81 },
82 instruments::{Instrument, InstrumentAny},
83 orders::{Order, OrderAny, TRIGGERABLE_ORDER_TYPES},
84 position::{Position, PositionReplayEvent},
85 reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
86 types::{Money, Quantity},
87};
88use rust_decimal::Decimal;
89use ustr::Ustr;
90
91#[cfg(feature = "node")]
92pub(crate) use super::reconciliation::collect_targeted_order_reports;
93pub(crate) use super::reconciliation::{
94 OpenOrderReconciliationResult, OpenOrderReportCheck, SourcedOrderStatusReport,
95 TargetedOrderQuery, TargetedOrderReportResult, request_targeted_order_reports,
96 resolve_position_report_client_coverage,
97};
98pub use super::{
99 config::ExecutionManagerConfig,
100 reconciliation::{
101 ExternalOrderMetadata, InflightCheckResult, InstrumentAccountKey, PositionFillReportPlan,
102 PositionFillReportPreparation, PositionFillReportQuery, PositionReportCheck,
103 ReconciliationResult, ReportClientCoverage,
104 },
105};
106use super::{
107 recency::RecencyMap,
108 reconciliation::{
109 FillKey, InflightCheck, PositionQuantityComparison, PositionReconciliationState,
110 PositionReportShape, ReconciliationFillQueue, RetainedFillState,
111 create_orphan_fill_order_report, create_position_reconciliation_report,
112 create_reconciliation_canceled, distinct_position_reports, has_active_inferred_fill,
113 is_exact_order_match, order_report_has_missing_fills, position_avg_px,
114 position_qty_aggregates, preserve_order_amendment, resolve_inferred_fill_commission,
115 responsible_client_ids, should_project_fill, sort_reconciliation_events,
116 },
117 submission::{SubmissionRecoveryExhausted, SubmissionRecoveryPolicy, SubmissionRecoverySource},
118};
119
120static TAG_VENUE: LazyLock<Ustr> = LazyLock::new(|| Ustr::from("VENUE"));
122
123static TAG_RECONCILIATION: LazyLock<Ustr> = LazyLock::new(|| Ustr::from(RECONCILIATION_ORDER_TAG));
125
126const LOG_SAMPLES_MAX: usize = 5;
127
128#[derive(Clone, Debug)]
129struct SubmissionRecoveryState {
130 trader_id: TraderId,
131 client_id: Option<ClientId>,
132 strategy_id: StrategyId,
133 instrument_id: InstrumentId,
134 exhausted: bool,
135 venue_confirmed: bool,
136}
137
138#[derive(Clone)]
152pub struct ExecutionManager {
153 clock: Rc<RefCell<dyn Clock>>,
154 cache: Rc<RefCell<Cache>>,
155 config: ExecutionManagerConfig,
156
157 order_activity: RecencyMap<ClientOrderId>,
158 order_inflight_checks: IndexMap<ClientOrderId, InflightCheck>,
159 submissions: IndexMap<ClientOrderId, SubmissionRecoveryState>,
160 submission_exhaustions: Vec<SubmissionRecoveryExhausted>,
161 submission_retention: IndexMap<ClientId, AccountId>,
162 order_query_recency: RecencyMap<ClientOrderId>,
163 order_query_pending: IndexSet<ClientOrderId>,
164 order_recon_retries: IndexMap<ClientOrderId, u32>,
165 order_coverage_unresolved: IndexSet<ClientOrderId>,
166 order_coverage_warnings: IndexSet<ClientOrderId>,
167 order_lookback_warnings: IndexSet<ClientOrderId>,
168
169 fills_processed: RecencyMap<FillKey>,
170 fills_recent: RecencyMap<FillKey>,
171 fills_unapplied: RecencyMap<FillKey>,
172
173 position_activity: RecencyMap<InstrumentAccountKey>,
174 position_activity_revisions: IndexMap<InstrumentAccountKey, u64>,
175 position_recon: IndexMap<InstrumentAccountKey, PositionReconciliationState>,
176 position_recon_tolerances: IndexMap<AccountId, Decimal>,
177}
178
179impl Debug for ExecutionManager {
180 #[rustfmt::skip]
181 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
182 f.debug_struct(stringify!(ExecutionManager))
183 .field("clock", &self.clock)
184 .field("cache", &self.cache)
185 .field("config", &self.config)
186 .field("order_activity", &self.order_activity)
187 .field("order_inflight_checks", &self.order_inflight_checks)
188 .field("submissions", &self.submissions)
189 .field("submission_exhaustions", &self.submission_exhaustions)
190 .field("submission_retention", &self.submission_retention)
191 .field("order_query_recency", &self.order_query_recency)
192 .field("order_query_pending", &self.order_query_pending)
193 .field("order_recon_retries", &self.order_recon_retries)
194 .field("order_coverage_unresolved", &self.order_coverage_unresolved)
195 .field("order_coverage_warnings", &self.order_coverage_warnings)
196 .field("order_lookback_warnings", &self.order_lookback_warnings)
197 .field("fills_processed", &self.fills_processed)
198 .field("fills_recent", &self.fills_recent)
199 .field("fills_unapplied", &self.fills_unapplied)
200 .field("position_activity", &self.position_activity)
201 .field("position_activity_revisions", &self.position_activity_revisions)
202 .field("position_recon", &self.position_recon)
203 .field("position_recon_tolerances", &self.position_recon_tolerances)
204 .finish()
205 }
206}
207
208impl ExecutionManager {
209 pub fn new(
215 clock: Rc<RefCell<dyn Clock>>,
216 cache: Rc<RefCell<Cache>>,
217 config: ExecutionManagerConfig,
218 ) -> ConfigResult<Self> {
219 config.validate()?;
220
221 Ok(Self {
222 clock,
223 cache,
224 config,
225 order_activity: RecencyMap::default(),
226 order_inflight_checks: IndexMap::new(),
227 submissions: IndexMap::new(),
228 submission_exhaustions: Vec::new(),
229 submission_retention: IndexMap::new(),
230 order_query_recency: RecencyMap::default(),
231 order_query_pending: IndexSet::new(),
232 order_recon_retries: IndexMap::new(),
233 order_coverage_unresolved: IndexSet::new(),
234 order_coverage_warnings: IndexSet::new(),
235 order_lookback_warnings: IndexSet::new(),
236 fills_processed: RecencyMap::default(),
237 fills_recent: RecencyMap::default(),
238 fills_unapplied: RecencyMap::default(),
239 position_activity: RecencyMap::default(),
240 position_activity_revisions: IndexMap::new(),
241 position_recon: IndexMap::new(),
242 position_recon_tolerances: IndexMap::new(),
243 })
244 }
245
246 pub(crate) const fn config(&self) -> &ExecutionManagerConfig {
248 &self.config
249 }
250
251 pub(crate) fn timestamp_ns(&self) -> UnixNanos {
253 self.clock.borrow().timestamp_ns()
254 }
255
256 pub(crate) fn cache(&self) -> Ref<'_, Cache> {
258 self.cache.borrow()
259 }
260
261 pub fn register_inflight(&mut self, client_order_id: ClientOrderId, command_id: UUID4) {
266 self.confirm_submission_outcome(&client_order_id);
267
268 if self.submission_recovery_pending(client_order_id)
269 && (self.order_inflight_checks.contains_key(&client_order_id)
270 || self.submission_is_retained(client_order_id))
271 {
272 return;
273 }
274
275 if self
276 .order_inflight_checks
277 .get(&client_order_id)
278 .is_none_or(|check| check.command_ids.is_empty())
279 {
280 self.start_inflight_check(client_order_id);
281 }
282
283 if let Some(check) = self.order_inflight_checks.get_mut(&client_order_id)
284 && !check.command_ids.contains(&command_id)
285 {
286 check.command_ids.push(command_id);
287 }
288 }
289
290 pub fn register_submission(
296 &mut self,
297 initialized: &OrderInitialized,
298 client_id: Option<ClientId>,
299 ) {
300 let client_order_id = initialized.client_order_id;
301 if self.submissions.contains_key(&client_order_id)
302 || self.submission_retention_enabled(client_order_id, client_id)
303 {
304 self.confirm_submission_outcome(&client_order_id);
305
306 if self.submissions.contains_key(&client_order_id)
307 || self.submission_is_acknowledged(client_order_id)
308 {
309 return;
310 }
311
312 self.track_submission(initialized, client_id);
313 }
314
315 self.start_inflight_check(client_order_id);
316 }
317
318 fn start_inflight_check(&mut self, client_order_id: ClientOrderId) {
319 if self
320 .config
321 .filtered_client_order_ids
322 .contains(&client_order_id)
323 {
324 return;
325 }
326
327 self.order_inflight_checks.insert(
328 client_order_id,
329 InflightCheck {
330 command_ids: Vec::new(),
331 submitted_at: dst::time::Instant::now(),
332 retry_count: 0,
333 last_query_at: None,
334 },
335 );
336
337 self.order_recon_retries.insert(client_order_id, 0);
338 self.order_query_recency.remove(&client_order_id);
339 self.order_activity.remove(&client_order_id);
340 }
341
342 fn track_submission(&mut self, initialized: &OrderInitialized, client_id: Option<ClientId>) {
343 if !self.submission_retention_enabled(initialized.client_order_id, client_id)
344 || self
345 .config
346 .filtered_client_order_ids
347 .contains(&initialized.client_order_id)
348 {
349 return;
350 }
351
352 self.submissions
353 .entry(initialized.client_order_id)
354 .or_insert(SubmissionRecoveryState {
355 trader_id: initialized.trader_id,
356 client_id,
357 strategy_id: initialized.strategy_id,
358 instrument_id: initialized.instrument_id,
359 exhausted: false,
360 venue_confirmed: false,
361 });
362 }
363
364 fn submission_is_unacknowledged(order: &OrderAny) -> bool {
365 !order.events().iter().any(|event| {
366 matches!(
367 event,
368 OrderEventAny::Accepted(_)
369 | OrderEventAny::Triggered(_)
370 | OrderEventAny::Filled(_)
371 | OrderEventAny::FillVoided(_)
372 | OrderEventAny::Rejected(_)
373 | OrderEventAny::Denied(_)
374 | OrderEventAny::Canceled(_)
375 | OrderEventAny::Expired(_)
376 ) || matches!(event, OrderEventAny::Updated(updated) if updated.venue_order_id.is_some())
377 })
378 }
379
380 fn submission_is_acknowledged(&self, client_order_id: ClientOrderId) -> bool {
381 self.cache
382 .borrow()
383 .order_ref(&client_order_id)
384 .is_some_and(|order| !Self::submission_is_unacknowledged(&order))
385 }
386
387 fn submission_recovery_pending(&self, client_order_id: ClientOrderId) -> bool {
388 self.submissions
389 .get(&client_order_id)
390 .is_some_and(|submission| !submission.venue_confirmed)
391 && !self.submission_is_acknowledged(client_order_id)
392 }
393
394 #[cfg(feature = "node")]
400 pub(crate) fn unresolved_submission_ids(&self) -> Vec<ClientOrderId> {
401 self.submissions
402 .keys()
403 .copied()
404 .filter(|client_order_id| self.submission_recovery_pending(*client_order_id))
405 .collect()
406 }
407
408 pub fn confirm_submission_outcome(&mut self, client_order_id: &ClientOrderId) {
413 let Some(submission) = self.submissions.get(client_order_id) else {
414 return;
415 };
416
417 let venue_confirmed = submission.venue_confirmed;
418
419 if !self.submission_is_acknowledged(*client_order_id) {
420 return;
421 }
422
423 if venue_confirmed {
424 self.submissions.shift_remove(client_order_id);
426 return;
427 }
428
429 self.clear_recon_tracking(client_order_id, true);
430 self.record_local_activity(*client_order_id);
431 }
432
433 fn exhaust_submission(
434 &mut self,
435 client_order_id: ClientOrderId,
436 source: SubmissionRecoverySource,
437 retry_count: u32,
438 ) -> bool {
439 if !self.submissions.contains_key(&client_order_id)
440 && !self.submission_retention_enabled(client_order_id, None)
441 {
442 return false;
443 }
444
445 let budget = match source {
446 SubmissionRecoverySource::Inflight => self.config.inflight_max_retries,
447 SubmissionRecoverySource::MissingOrder => self.config.open_check_missing_retries,
448 };
449
450 if retry_count < budget {
451 return false;
452 }
453
454 if let Some(order) = self.get_order(client_order_id) {
455 if !Self::submission_is_unacknowledged(&order) {
456 return false;
457 }
458
459 let client_id = self.cache.borrow().client_id(&client_order_id).copied();
460 self.track_submission(order.init_event(), client_id);
461 }
462
463 let Some(submission) = self.submissions.get_mut(&client_order_id) else {
464 return false;
465 };
466
467 if submission.venue_confirmed {
468 return false;
469 }
470
471 if !submission.exhausted {
472 submission.exhausted = true;
473 self.submission_exhaustions
474 .push(SubmissionRecoveryExhausted {
475 trader_id: submission.trader_id,
476 client_id: submission
477 .client_id
478 .or_else(|| self.cache.borrow().client_id(&client_order_id).copied()),
479 strategy_id: submission.strategy_id,
480 instrument_id: submission.instrument_id,
481 client_order_id,
482 source,
483 retry_count,
484 ts_event: self.clock.borrow().timestamp_ns(),
485 });
486
487 log::warn!(
488 "Submission recovery exhausted for {client_order_id}, retaining unacknowledged order pending venue evidence"
489 );
490 }
491
492 self.clear_recon_tracking(&client_order_id, true);
493 true
494 }
495
496 pub fn take_submission_recovery_exhaustions(&mut self) -> Vec<SubmissionRecoveryExhausted> {
503 std::mem::take(&mut self.submission_exhaustions)
504 }
505
506 pub fn record_local_activity(&mut self, client_order_id: ClientOrderId) {
513 self.order_activity.mark(client_order_id);
514 }
515
516 #[must_use]
520 pub fn recon_check_retry_count(&self, client_order_id: &ClientOrderId) -> u32 {
521 self.order_recon_retries
522 .get(client_order_id)
523 .copied()
524 .unwrap_or(0)
525 }
526
527 pub(crate) fn remove_targeted_order_queries(&mut self, client_order_ids: &[ClientOrderId]) {
529 for client_order_id in client_order_ids {
530 self.order_query_pending.shift_remove(client_order_id);
531 }
532 }
533
534 pub fn clear_recon_tracking(&mut self, client_order_id: &ClientOrderId, drop_last_query: bool) {
540 let pending = self.submission_recovery_pending(*client_order_id);
541 if pending && !self.submission_is_retained(*client_order_id) {
542 return;
543 }
544
545 self.order_inflight_checks.shift_remove(client_order_id);
546
547 let keep_confirmation = self
548 .submissions
549 .get(client_order_id)
550 .is_some_and(|submission| submission.venue_confirmed)
551 && self
552 .cache
553 .borrow()
554 .order_ref(client_order_id)
555 .is_some_and(|order| Self::submission_is_unacknowledged(&order));
556
557 if !pending && !keep_confirmation {
558 self.submissions.shift_remove(client_order_id);
559 }
560
561 self.order_recon_retries.shift_remove(client_order_id);
562 self.order_coverage_warnings.shift_remove(client_order_id);
563 self.order_lookback_warnings.shift_remove(client_order_id);
564 self.order_coverage_unresolved.shift_remove(client_order_id);
565 self.remove_targeted_order_queries(&[*client_order_id]);
566 if drop_last_query {
567 self.order_query_recency.remove(client_order_id);
568 }
569
570 self.order_activity.remove(client_order_id);
571 }
572
573 pub fn prune_order_local_activity(&mut self) {
575 self.order_activity
576 .prune_older_than(Duration::from(self.config.open_check_threshold_ns));
577 }
578
579 #[must_use]
581 pub fn is_fill_recently_processed(
582 &self,
583 account_id: AccountId,
584 instrument_id: InstrumentId,
585 trade_id: TradeId,
586 ) -> bool {
587 self.fills_recent
588 .contains_key(&(account_id, instrument_id, trade_id))
589 }
590
591 pub fn commit_recent_fill_if_applied(&mut self, fill: &OrderFilled) {
593 let fill_key = (fill.account_id, fill.instrument_id, fill.trade_id);
594 if self.applied_fill_key(fill) == Some(fill_key) {
595 self.mark_fill_processed(fill_key.0, fill_key.1, fill_key.2);
596 }
597 }
598
599 pub fn mark_fill_processed(
601 &mut self,
602 account_id: AccountId,
603 instrument_id: InstrumentId,
604 trade_id: TradeId,
605 ) {
606 self.fills_recent
607 .mark((account_id, instrument_id, trade_id));
608 }
609
610 pub fn prune_recent_fills_cache(&mut self, ttl_secs: f64) {
614 let ttl = match Duration::try_from_secs_f64(ttl_secs) {
622 Ok(ttl) => ttl,
623 Err(_) if ttl_secs > 0.0 => Duration::MAX,
624 Err(_) => Duration::ZERO,
625 };
626
627 self.fills_recent.prune_older_than(ttl);
628 }
629
630 pub fn prune_processed_fills(&mut self) {
635 let Some(lookback_mins) = self.config.lookback_mins else {
636 return;
637 };
638
639 let ttl = Duration::from_mins(lookback_mins).max(Duration::from_mins(1));
640 self.fills_processed.prune_older_than(ttl);
641 }
642
643 pub(crate) fn set_position_reconciliation_tolerance(
645 &mut self,
646 account_id: AccountId,
647 tolerance: Decimal,
648 ) {
649 let tolerance = if tolerance < Decimal::ZERO {
650 log::error!(
651 "Invalid negative position reconciliation tolerance {tolerance} for \
652 {account_id}; using the default"
653 );
654 DEFAULT_POSITION_RECONCILIATION_TOLERANCE
655 } else {
656 tolerance
657 };
658
659 self.position_recon_tolerances.insert(account_id, tolerance);
660 }
661
662 pub(crate) fn position_reconciliation_tolerance(&self, account_id: AccountId) -> Decimal {
664 self.position_recon_tolerances
665 .get(&account_id)
666 .copied()
667 .unwrap_or(DEFAULT_POSITION_RECONCILIATION_TOLERANCE)
668 }
669
670 pub fn record_position_activity(&mut self, instrument_id: InstrumentId, account_id: AccountId) {
676 let key = (instrument_id, account_id);
677 self.position_activity.mark(key);
678 let revision = self.position_activity_revisions.entry(key).or_default();
679 *revision = revision.saturating_add(1);
680 }
681
682 pub(crate) fn position_activity_is_recent(&self, key: &InstrumentAccountKey) -> bool {
684 self.position_activity
685 .within(key, Duration::from(self.config.position_check_threshold_ns))
686 }
687
688 pub(crate) fn position_activity_revision(&self, key: &InstrumentAccountKey) -> u64 {
690 self.position_activity_revisions
691 .get(key)
692 .copied()
693 .unwrap_or_default()
694 }
695
696 fn set_position_reconciliation_retries(
697 &mut self,
698 key: InstrumentAccountKey,
699 report_shape: PositionReportShape,
700 retries: u32,
701 ) {
702 self.position_recon.insert(
703 key,
704 PositionReconciliationState {
705 report_shape,
706 retries,
707 },
708 );
709 }
710
711 fn position_reconciliation_retries(
713 &self,
714 key: &InstrumentAccountKey,
715 report_shape: PositionReportShape,
716 ) -> u32 {
717 self.position_recon
718 .get(key)
719 .filter(|state| state.report_shape == report_shape)
720 .map_or(0, |state| state.retries)
721 }
722
723 #[must_use]
726 pub fn position_recon_retry_count(&self, key: &InstrumentAccountKey) -> u32 {
727 self.position_recon
728 .get(key)
729 .map_or(0, |state| state.retries)
730 }
731
732 pub(crate) fn clear_position_reconciliation(&mut self, key: &InstrumentAccountKey) {
734 self.position_recon.shift_remove(key);
735 }
736
737 pub(crate) fn retain_position_reconciliation(
739 &mut self,
740 active_keys: &IndexSet<InstrumentAccountKey>,
741 ) {
742 self.position_recon
743 .retain(|key, _| active_keys.contains(key));
744 }
745
746 pub fn reconcile_execution_mass_status(
752 &mut self,
753 mass_status: &ExecutionMassStatus,
754 exec_engine: &RefCell<ExecutionEngine>,
755 ) -> ReconciliationResult {
756 if exec_engine
757 .borrow()
758 .get_client(&mass_status.client_id)
759 .is_none()
760 {
761 log::error!(
762 "Cannot reconcile ExecutionMassStatus from unknown client {}",
763 mass_status.client_id
764 );
765 return ReconciliationResult::default();
766 }
767
768 self.validate_mass_status_order_sources(mass_status);
769
770 let raw_order_status_topic =
775 MessagingSwitchboard::reconciliation_raw_order_status_report_topic();
776
777 for report in mass_status.order_reports().values() {
778 msgbus::publish_any(raw_order_status_topic, report);
779 }
780
781 let raw_fill_topic = MessagingSwitchboard::reconciliation_raw_fill_report_topic();
782
783 for fills in mass_status.fill_reports().values() {
784 for fill in fills {
785 msgbus::publish_any(raw_fill_topic, fill);
786 }
787 }
788
789 let raw_position_topic =
790 MessagingSwitchboard::reconciliation_raw_position_status_report_topic();
791
792 for reports in mass_status.position_reports().values() {
793 for report in reports {
794 msgbus::publish_any(raw_position_topic, report);
795 }
796 }
797
798 if exec_engine
799 .borrow()
800 .get_client(&mass_status.client_id)
801 .is_none()
802 {
803 log::error!(
804 "Execution client {} disappeared while publishing raw mass status reports",
805 mass_status.client_id
806 );
807 return ReconciliationResult::default();
808 }
809
810 let venue = mass_status.venue;
811 let order_count = mass_status.order_reports().len();
812 let fill_count: usize = mass_status.fill_reports().values().map(Vec::len).sum();
813 let position_count: usize = mass_status.position_reports().values().map(Vec::len).sum();
814
815 log_info!(
816 "Reconciling ExecutionMassStatus for {venue}",
817 color = LogColor::Blue
818 );
819 log_info!(
820 "Received {order_count} order(s), {fill_count} fill(s), {position_count} position(s)",
821 color = LogColor::Blue
822 );
823
824 if mass_status.lookback_start().is_some() && !mass_status.reports_complete() {
825 log::warn!("Received incomplete bounded reconciliation reports for {venue}");
826 }
827
828 let retained_fill_state = self.retained_fill_state();
829
830 let reported_fill_keys: IndexSet<FillKey> = mass_status
831 .fill_reports()
832 .values()
833 .flatten()
834 .filter(|fill| !fill.last_qty.is_zero())
835 .map(|fill| (fill.account_id, fill.instrument_id, fill.trade_id))
836 .collect();
837
838 let order_venue_ids = exec_engine
839 .borrow()
840 .get_client(&mass_status.client_id)
841 .and_then(|client| client.venue_order_ids(mass_status));
842 let mut adjusted_reports = self.adjust_mass_status_fills(mass_status);
843 Self::preserve_external_order_history(
844 mass_status,
845 order_venue_ids.as_ref(),
846 &mut adjusted_reports,
847 );
848 let AdjustedReports {
849 orders: adjusted_order_reports,
850 fills: adjusted_fill_reports,
851 order_only_ids,
852 order_only_fill_keys,
853 } = adjusted_reports;
854
855 let bounded_order_only_ids =
856 self.order_only_ids(mass_status, &adjusted_order_reports, &adjusted_fill_reports);
857
858 let mut events = Vec::new();
859 let mut external_orders = Vec::new();
860 let mut orders_reconciled = 0usize;
861 let mut external_orders_created = 0usize;
862 let mut open_orders_initialized = 0usize;
863 let mut orders_skipped_no_instrument = 0usize;
864 let mut orders_skipped_duplicate = 0usize;
865 let mut fills_applied = 0usize;
866 let mut fill_queue = ReconciliationFillQueue::default();
867
868 let fill_reports = &adjusted_fill_reports;
869 let mut seen_fill_keys: IndexSet<FillKey> = IndexSet::new();
870
871 for fills in fill_reports.values() {
872 for fill in fills {
873 let fill_key = (fill.account_id, fill.instrument_id, fill.trade_id);
874 if !seen_fill_keys.insert(fill_key) {
875 log::warn!(
876 "Duplicate trade_id {} for {} in mass status",
877 fill.trade_id,
878 fill.instrument_id
879 );
880 }
881 }
882 }
883
884 let order_reports = &adjusted_order_reports;
885 let mut orders_skipped_filtered = 0usize;
886 let mut orders_projected: IndexMap<ClientOrderId, OrderAny> = IndexMap::new();
887
888 for report in order_reports.values().filter(|report| {
889 order_venue_ids
890 .as_ref()
891 .and_then(|histories| report.client_order_id.and_then(|id| histories.get(&id)))
892 .is_none_or(|ids| ids.last() == Some(&report.venue_order_id))
893 }) {
894 if self.should_skip_order_report(report) {
895 orders_skipped_filtered += 1;
896 continue;
897 }
898
899 let order = report
900 .client_order_id
901 .and_then(|id| {
902 orders_projected
903 .get(&id)
904 .cloned()
905 .or_else(|| self.get_order(id))
906 })
907 .or_else(|| {
908 self.get_order_by_venue_order_id(report.venue_order_id)
909 .map(|order| {
910 orders_projected
911 .get(&order.client_order_id())
912 .cloned()
913 .unwrap_or(order)
914 })
915 });
916
917 let order_client = order
918 .as_ref()
919 .filter(|order| Some(order.client_order_id()) == report.client_order_id);
920 let events_start = events.len();
921
922 if let Some(client_order_id) = &report.client_order_id {
923 if let Some(cached_order) = order_client
924 && is_exact_order_match(cached_order, report)
925 {
926 log::debug!("Skipping order {client_order_id}: already in sync with venue");
927 orders_skipped_duplicate += 1;
928
929 if let Err(e) = self
931 .cache
932 .borrow_mut()
933 .index_venue_order_id(client_order_id, &report.venue_order_id)
934 {
935 log::warn!("Failed to index venue order ID: {e}");
936 }
937
938 continue;
939 }
940
941 if let Some(cached_order) = order_client
943 && cached_order.is_closed()
944 && cached_order
945 .tags()
946 .is_some_and(|tags| tags.contains(&*TAG_RECONCILIATION))
947 {
948 log::debug!(
949 "Skipping closed reconciliation order {client_order_id}: \
950 synthetic position adjustment from previous session",
951 );
952 orders_skipped_duplicate += 1;
953 continue;
954 }
955 }
956
957 if let Some(order) = order.as_ref() {
958 let instrument = self.get_instrument(&report.instrument_id);
959
960 if order_client.is_some() {
961 log::info!(
962 color = LogColor::Blue as u8;
963 "Reconciling {} {} {} [{}] -> [{}]",
964 order.client_order_id(),
965 report.venue_order_id,
966 report.instrument_id,
967 order.status(),
968 report.order_status,
969 );
970 } else {
971 log::info!(
973 color = LogColor::Blue as u8;
974 "Reconciling {} (matched by venue_order_id {}) {} [{}] -> [{}]",
975 order.client_order_id(),
976 report.venue_order_id,
977 report.instrument_id,
978 order.status(),
979 report.order_status,
980 );
981 }
982
983 let order_fills: Vec<&FillReport> = fill_reports
984 .get(&report.venue_order_id)
985 .map(|f| f.iter().collect())
986 .unwrap_or_default();
987 let engine_ref = exec_engine.borrow();
988 let commission_client = engine_ref.get_client(&mass_status.client_id);
989
990 let order_events = self.reconcile_order_with_fills(
991 true,
992 order,
993 report,
994 &order_fills,
995 instrument.as_ref(),
996 &mut fill_queue,
997 commission_client,
998 );
999
1000 drop(engine_ref);
1001
1002 orders_reconciled += usize::from(!order_events.is_empty());
1003 fills_applied += order_events
1004 .iter()
1005 .filter(|e| matches!(e, OrderEventAny::Filled(_)))
1006 .count();
1007 events.extend(order_events);
1008
1009 if let Err(e) = self
1011 .cache
1012 .borrow_mut()
1013 .index_venue_order_id(&order.client_order_id(), &report.venue_order_id)
1014 {
1015 log::warn!("Failed to index venue order ID: {e}");
1016 }
1017 } else if let Some(instrument) = self.get_instrument(&report.instrument_id) {
1018 let is_synthetic = report.client_order_id.is_none()
1020 && report.venue_order_id.as_str().starts_with("S-");
1021
1022 let venue_order_ids = report.client_order_id.and_then(|client_order_id| {
1023 order_venue_ids
1024 .as_ref()
1025 .and_then(|histories| histories.get(&client_order_id))
1026 });
1027
1028 let order_fills: Vec<&FillReport> = venue_order_ids
1029 .map_or(std::slice::from_ref(&report.venue_order_id), Vec::as_slice)
1030 .iter()
1031 .filter_map(|id| fill_reports.get(id))
1032 .flatten()
1033 .collect();
1034 let engine_ref = exec_engine.borrow();
1035 let commission_client = engine_ref.get_client(&mass_status.client_id);
1036
1037 let (mut external_events, metadata) = self.handle_external_order(
1038 report,
1039 mass_status.account_id,
1040 &instrument,
1041 &order_fills,
1042 is_synthetic,
1043 Some(&mut fill_queue),
1044 commission_client,
1045 );
1046
1047 drop(engine_ref);
1048
1049 self.restore_external_order_venue_ids(
1050 report,
1051 venue_order_ids.map(Vec::as_slice),
1052 &mut external_events,
1053 );
1054
1055 if !external_events.is_empty() {
1056 external_orders_created += 1;
1057 fills_applied += external_events
1058 .iter()
1059 .filter(|e| matches!(e, OrderEventAny::Filled(_)))
1060 .count();
1061
1062 if report.order_status.is_open() {
1063 open_orders_initialized += 1;
1064 }
1065
1066 events.extend(external_events);
1067
1068 if let Some(m) = metadata {
1069 external_orders.push(m);
1070 }
1071 }
1072 } else {
1073 orders_skipped_no_instrument += 1;
1074 }
1075
1076 if events.len() > events_start
1077 && let Some(mut order) = order
1078 {
1079 for event in &events[events_start..] {
1080 if event.client_order_id() == order.client_order_id()
1081 && let Err(e) = order.apply(event.clone())
1082 {
1083 log::warn!("Cannot project queued reconciliation event: {e}");
1084 }
1085 }
1086
1087 orders_projected.insert(order.client_order_id(), order);
1088 }
1089 }
1090
1091 let mut dropped_fill_groups: Vec<(VenueOrderId, InstrumentId, usize)> = Vec::new();
1093
1094 for (venue_order_id, fills) in fill_reports {
1095 if order_reports.contains_key(venue_order_id) {
1096 continue;
1097 }
1098
1099 let Some(first_fill) = fills.first() else {
1100 continue;
1101 };
1102
1103 if !self.should_reconcile_instrument(&first_fill.instrument_id) {
1104 log::debug!(
1105 "Skipping orphan fills for {}: not in reconciliation_instrument_ids",
1106 first_fill.instrument_id
1107 );
1108 continue;
1109 }
1110
1111 if let Some(client_order_id) = &first_fill.client_order_id
1113 && self
1114 .config
1115 .filtered_client_order_ids
1116 .contains(client_order_id)
1117 {
1118 log::debug!(
1119 "Skipping orphan fills for {client_order_id}: in filtered_client_order_ids"
1120 );
1121 continue;
1122 }
1123
1124 let order = first_fill
1125 .client_order_id
1126 .as_ref()
1127 .and_then(|id| self.get_order(*id))
1128 .or_else(|| self.get_order_by_venue_order_id(*venue_order_id));
1129
1130 if let Some(ref order) = order
1132 && self
1133 .config
1134 .filtered_client_order_ids
1135 .contains(&order.client_order_id())
1136 {
1137 log::debug!(
1138 "Skipping orphan fills for {}: in filtered_client_order_ids",
1139 order.client_order_id()
1140 );
1141 continue;
1142 }
1143
1144 if let Some(order) = order {
1145 let instrument_id = order.instrument_id();
1146 if let Some(instrument) = self.get_instrument(&instrument_id) {
1147 let mut sorted_fills: Vec<&FillReport> = fills.iter().collect();
1148 sorted_fills.sort_by_key(|f| f.ts_event);
1149
1150 for fill in sorted_fills {
1151 if let Some((event, fill_key)) = self.create_order_fill(
1152 &order,
1153 fill,
1154 &instrument,
1155 &fill_queue.pending_fill_keys,
1156 ) {
1157 fills_applied += 1;
1158 fill_queue.push(&mut events, event, fill_key);
1159 }
1160 }
1161 } else {
1162 orders_skipped_no_instrument += 1;
1163 }
1164 } else if fills.iter().any(FillReport::has_venue_position_id) {
1165 if !self.config.generate_missing_orders {
1166 log::debug!(
1167 "Skipping orphan fills for venue order {venue_order_id}: \
1168 `generate_missing_orders` is disabled"
1169 );
1170 orders_skipped_filtered += 1;
1171 continue;
1172 }
1173
1174 let Some(instrument) = self.get_instrument(&first_fill.instrument_id) else {
1175 orders_skipped_no_instrument += 1;
1176 continue;
1177 };
1178
1179 let mut sorted_fills: Vec<&FillReport> = fills.iter().collect();
1180 sorted_fills.sort_by_key(|fill| fill.ts_event);
1181
1182 let report = match create_orphan_fill_order_report(&sorted_fills, &instrument) {
1183 Ok(report) => report,
1184 Err(e) => {
1185 log::error!(
1186 "Cannot materialize orphan fills for venue order {venue_order_id}: {e}"
1187 );
1188
1189 continue;
1190 }
1191 };
1192
1193 let engine_ref = exec_engine.borrow();
1194 let commission_client = engine_ref.get_client(&mass_status.client_id);
1195
1196 let (external_events, metadata) = self.handle_external_order(
1197 &report,
1198 mass_status.account_id,
1199 &instrument,
1200 &sorted_fills,
1201 false,
1202 Some(&mut fill_queue),
1203 commission_client,
1204 );
1205
1206 drop(engine_ref);
1207
1208 if !external_events.is_empty() {
1209 external_orders_created += 1;
1210 fills_applied += external_events
1211 .iter()
1212 .filter(|event| matches!(event, OrderEventAny::Filled(_)))
1213 .count();
1214
1215 events.extend(external_events);
1216
1217 if let Some(metadata) = metadata {
1218 external_orders.push(metadata);
1219 }
1220 }
1221 } else {
1222 log::debug!(
1223 "Dropping {} fill(s) for venue order {venue_order_id} ({}): \
1224 no order report or cached order",
1225 fills.len(),
1226 first_fill.instrument_id,
1227 );
1228 dropped_fill_groups.push((*venue_order_id, first_fill.instrument_id, fills.len()));
1229 }
1230 }
1231
1232 sort_reconciliation_events(&mut events);
1233
1234 let recover_closing_fills = mass_status.lookback_start().is_some()
1235 && mass_status.reports_complete()
1236 && !self.config.filter_position_reports;
1237 let mut uncovered_instruments: IndexMap<InstrumentId, bool> = IndexMap::new();
1238 let mut withheld_fills: IndexMap<_, Vec<_>> = IndexMap::new();
1239 let mut unapplied_fill_position_ids = IndexSet::new();
1240
1241 for event in &events {
1242 let OrderEventAny::Filled(fill) = event else {
1243 exec_engine.borrow_mut().process(event);
1244 continue;
1245 };
1246
1247 let fill_key = (fill.account_id, fill.instrument_id, fill.trade_id);
1248 let queued_fill_key = fill_queue.event_fill_keys.get(&fill.event_id).copied();
1249 let historical = should_project_fill(
1250 fill,
1251 &retained_fill_state,
1252 &reported_fill_keys,
1253 &order_only_ids,
1254 &order_only_fill_keys,
1255 );
1256 let bounded = !historical && bounded_order_only_ids.contains(&fill.venue_order_id);
1257
1258 let uncovered = bounded
1259 && *uncovered_instruments
1260 .entry(fill.instrument_id)
1261 .or_insert_with(|| {
1262 exec_engine
1263 .borrow()
1264 .get_client(&mass_status.client_id)
1265 .is_some_and(|client| {
1266 !client.provides_bulk_position_coverage(fill.instrument_id)
1267 })
1268 });
1269
1270 let recovered = uncovered
1271 && recover_closing_fills
1272 && queued_fill_key == Some(fill_key)
1273 && self.fill_reduces_position(fill, &exec_engine.borrow());
1274
1275 let withheld_position_id =
1278 (uncovered && !recovered && self.applied_fill_key(fill) != Some(fill_key))
1279 .then(|| exec_engine.borrow().reconciliation_position_id(fill));
1280 if historical || bounded && !recovered {
1281 exec_engine.borrow_mut().project_reconciliation_fill(fill);
1282 } else {
1283 exec_engine.borrow_mut().process(event);
1284 }
1285
1286 let applied_fill_key = self.applied_fill_key(fill);
1287
1288 if let Some(position_id) = withheld_position_id
1289 && applied_fill_key == Some(fill_key)
1290 {
1291 withheld_fills
1292 .entry((fill.account_id, fill.instrument_id, position_id))
1293 .or_default()
1294 .push((fill.trade_id, fill.client_order_id));
1295 }
1296
1297 if let Some(fill_key) = queued_fill_key {
1298 if applied_fill_key == Some(fill_key) {
1299 self.fills_processed.mark(fill_key);
1300 } else if let Some(venue_position_id) = fill.position_id {
1301 log::error!(
1302 "Skipping reconciliation for venue position {venue_position_id}: historical fill {} was not applied",
1303 fill.trade_id,
1304 );
1305
1306 unapplied_fill_position_ids.insert(venue_position_id);
1307 }
1308 }
1309 }
1310
1311 let mut positions_created = 0usize;
1312
1313 if !self.config.filter_position_reports {
1314 let instruments_with_unattributed_fills: IndexSet<InstrumentId> = mass_status
1317 .fill_reports()
1318 .values()
1319 .flatten()
1320 .filter(|f| !f.last_qty.is_zero() && f.venue_position_id.is_none())
1321 .map(|f| f.instrument_id)
1322 .chain(
1323 mass_status
1324 .order_reports()
1325 .values()
1326 .filter(|r| !r.filled_qty.is_zero() && r.venue_position_id.is_none())
1327 .map(|r| r.instrument_id),
1328 )
1329 .collect();
1330
1331 for (instrument_id, reports) in mass_status.position_reports() {
1332 if !self.should_reconcile_instrument(&instrument_id) {
1333 log::debug!(
1334 "Skipping position reports for {instrument_id}: not in reconciliation_instrument_ids"
1335 );
1336 continue;
1337 }
1338
1339 for report in reports {
1340 if report.venue_position_id.is_some_and(|venue_position_id| {
1341 unapplied_fill_position_ids.contains(&venue_position_id)
1342 }) {
1343 continue;
1344 }
1345
1346 if let Some(position_events) = self.reconcile_position_report(
1347 &report,
1348 mass_status.account_id,
1349 &instruments_with_unattributed_fills,
1350 ) {
1351 for event in position_events {
1352 exec_engine.borrow_mut().process(&event);
1353 events.push(event);
1354 }
1355
1356 positions_created += 1;
1357 }
1358 }
1359 }
1360 }
1361
1362 if orders_skipped_no_instrument > 0 {
1363 log::warn!("{orders_skipped_no_instrument} orders skipped (instrument not in cache)");
1364 }
1365
1366 if !dropped_fill_groups.is_empty() {
1367 let dropped_fill_count: usize =
1368 dropped_fill_groups.iter().map(|(_, _, count)| count).sum();
1369
1370 let samples = dropped_fill_groups
1371 .iter()
1372 .take(LOG_SAMPLES_MAX)
1373 .map(|(venue_order_id, instrument_id, _)| {
1374 format!("{venue_order_id} ({instrument_id})")
1375 })
1376 .collect::<Vec<_>>()
1377 .join(", ");
1378
1379 log::warn!(
1380 "Dropped {dropped_fill_count} fill(s) in {} fill group(s) without an order report \
1381 or cached order ({samples})",
1382 dropped_fill_groups.len(),
1383 );
1384 }
1385
1386 for ((account_id, instrument_id, position_id), fills) in &withheld_fills {
1387 let target = position_id.map_or_else(
1388 || "with no resolvable position".to_string(),
1389 |position_id| format!("not to position {position_id}"),
1390 );
1391 let samples = fills
1392 .iter()
1393 .take(LOG_SAMPLES_MAX)
1394 .map(|(trade_id, client_order_id)| format!("{trade_id} ({client_order_id})"))
1395 .collect::<Vec<_>>()
1396 .join(", ");
1397
1398 log::warn!(
1399 "Applied {} bounded fill(s) for {instrument_id} on {account_id} to order state \
1400 only, {target} ({samples}): exposure and PnL may need manual reconciliation",
1401 fills.len(),
1402 );
1403 }
1404
1405 if orders_skipped_duplicate > 0 {
1406 log::debug!("{orders_skipped_duplicate} orders skipped (already in sync)");
1407 }
1408
1409 if orders_skipped_filtered > 0 {
1410 log::debug!("{orders_skipped_filtered} orders skipped (filtered by config)");
1411 }
1412
1413 log::info!(
1414 color = LogColor::Blue as u8;
1415 "Reconciliation complete for {venue}: reconciled={orders_reconciled}, external={external_orders_created}, open={open_orders_initialized}, fills={fills_applied}, positions={positions_created}, skipped={orders_skipped_duplicate}, filtered={orders_skipped_filtered}",
1416 );
1417
1418 ReconciliationResult {
1419 events,
1420 external_orders,
1421 unresolved_positions: self.unresolved_mass_status_positions(mass_status),
1422 }
1423 }
1424
1425 fn preserve_external_order_history(
1426 mass_status: &ExecutionMassStatus,
1427 order_venue_ids: Option<&IndexMap<ClientOrderId, Vec<VenueOrderId>>>,
1428 adjusted: &mut AdjustedReports,
1429 ) {
1430 let Some(order_venue_ids) = order_venue_ids else {
1431 return;
1432 };
1433
1434 let reports = mass_status.order_reports();
1435 let fills = mass_status.fill_reports();
1436
1437 for id in order_venue_ids.values().flatten() {
1438 if let Some(report) = reports.get(id) {
1439 adjusted.orders.entry(*id).or_insert_with(|| report.clone());
1440 }
1441
1442 let retained = adjusted.fills.entry(*id).or_default();
1443 for fill in fills.get(id).into_iter().flatten() {
1444 if !fill.last_qty.is_zero()
1445 && !retained
1446 .iter()
1447 .any(|existing| existing.trade_id == fill.trade_id)
1448 {
1449 adjusted.order_only_fill_keys.insert((
1451 fill.account_id,
1452 fill.instrument_id,
1453 fill.trade_id,
1454 ));
1455 retained.push(fill.clone());
1456 }
1457 }
1458 }
1459 }
1460
1461 fn restore_external_order_venue_ids(
1462 &self,
1463 report: &OrderStatusReport,
1464 venue_order_ids: Option<&[VenueOrderId]>,
1465 events: &mut Vec<OrderEventAny>,
1466 ) {
1467 let Some((first, remaining)) = venue_order_ids.and_then(|ids| ids.split_first()) else {
1468 return;
1469 };
1470
1471 let Some(OrderEventAny::Accepted(mut accepted)) = events.first().cloned() else {
1472 return;
1473 };
1474
1475 let Some(order) = report.client_order_id.and_then(|id| self.get_order(id)) else {
1476 return;
1477 };
1478
1479 accepted.venue_order_id = *first;
1480 let mut lifecycle = vec![OrderEventAny::Accepted(accepted)];
1481
1482 for venue_order_id in remaining {
1484 lifecycle.push(OrderEventAny::Updated(OrderUpdated::new(
1485 order.trader_id(),
1486 order.strategy_id(),
1487 order.instrument_id(),
1488 order.client_order_id(),
1489 order.quantity(),
1490 UUID4::new(),
1491 report.ts_accepted,
1492 self.clock.borrow().timestamp_ns(),
1493 true,
1494 Some(*venue_order_id),
1495 Some(accepted.account_id),
1496 order.price(),
1497 order.trigger_price(),
1498 None,
1499 order.is_quote_quantity(),
1500 )));
1501 }
1502
1503 if let Err(e) =
1504 self.cache
1505 .borrow_mut()
1506 .add_venue_order_id(&order.client_order_id(), first, true)
1507 {
1508 log::error!("Cannot initialize venue order ID history: {e}");
1509 return;
1510 }
1511
1512 events.splice(..1, lifecycle);
1513 }
1514
1515 fn unresolved_mass_status_positions(&self, mass_status: &ExecutionMassStatus) -> Vec<String> {
1516 if self.config.filter_position_reports {
1517 return Vec::new();
1518 }
1519
1520 let mut unresolved = Vec::new();
1521
1522 for (instrument_id, reports) in mass_status.position_reports() {
1523 if !self.should_reconcile_instrument(&instrument_id) {
1524 continue;
1525 }
1526
1527 let reports = distinct_position_reports(reports);
1528
1529 if self
1530 .netting_position_reports_match((instrument_id, mass_status.account_id), &reports)
1531 {
1532 continue;
1533 }
1534
1535 for report in &reports {
1536 if let Some(reason) =
1537 self.unresolved_position_report(report, mass_status.account_id, &reports)
1538 {
1539 unresolved.push(reason);
1540 }
1541 }
1542 }
1543
1544 unresolved
1545 }
1546
1547 fn netting_position_reports_match(
1548 &self,
1549 key: InstrumentAccountKey,
1550 reports: &[PositionStatusReport],
1551 ) -> bool {
1552 let comparison = self.position_quantity_comparison(key, reports);
1553 let cache = self.cache.borrow();
1554 !comparison.cached_positions.is_empty()
1555 && comparison
1556 .cached_positions
1557 .iter()
1558 .all(|position| cache.oms_type(&position.id) == Some(OmsType::Netting))
1559 && comparison.quantities_match(self.position_reconciliation_tolerance(key.1))
1560 && self.position_report_prices_match(&comparison.cached_positions, reports)
1561 }
1562
1563 fn unresolved_position_report(
1564 &self,
1565 report: &PositionStatusReport,
1566 account_id: AccountId,
1567 reports: &[PositionStatusReport],
1568 ) -> Option<String> {
1569 let cache = self.cache.borrow();
1570 let instrument_id = report.instrument_id;
1571
1572 let open_positions =
1573 cache.positions_open(None, Some(&instrument_id), None, Some(&account_id), None);
1574 let is_netting = !open_positions.is_empty()
1575 && open_positions
1576 .iter()
1577 .all(|position| cache.oms_type(&position.id) == Some(OmsType::Netting));
1578
1579 let venue_position_id = report.venue_position_id.filter(|_| !is_netting);
1580 let venue_qty = report.signed_decimal_qty;
1581
1582 let cached_positions: Vec<Position> = if let Some(position_id) = venue_position_id {
1583 cache
1584 .position(&position_id)
1585 .filter(|p| p.account_id == account_id && p.instrument_id == instrument_id)
1586 .into_iter()
1587 .map(|p| (*p).clone())
1588 .collect()
1589 } else {
1590 open_positions.into_iter().map(|p| (*p).clone()).collect()
1591 };
1592
1593 let cached_qty: Decimal = cached_positions
1594 .iter()
1595 .map(Position::signed_decimal_qty)
1596 .sum();
1597
1598 let quantities_match = if is_netting {
1599 self.position_quantity_comparison((instrument_id, account_id), reports)
1600 .quantities_match(self.position_reconciliation_tolerance(account_id))
1601 } else if venue_position_id.is_some() {
1602 cached_qty == venue_qty
1603 } else {
1604 (cached_qty - venue_qty).abs() <= self.position_reconciliation_tolerance(account_id)
1605 };
1606
1607 let price_reports = if is_netting {
1608 reports
1609 } else {
1610 std::slice::from_ref(report)
1611 };
1612
1613 let prices_match = self.position_report_prices_match(&cached_positions, price_reports);
1614
1615 if quantities_match && prices_match {
1616 return None;
1617 }
1618
1619 let reason = if cache.instrument(&instrument_id).is_none() {
1620 "instrument missing from cache"
1621 } else if cache.account(&account_id).is_none() {
1622 "account missing from cache"
1623 } else if !self.config.generate_missing_orders {
1624 "generate_missing_orders is disabled"
1625 } else if report.avg_px_open.is_none() && cached_qty == Decimal::ZERO {
1626 "missing avg_px_open for position recovery"
1627 } else if quantities_match {
1628 "position recovery did not restore the reported average entry price"
1629 } else {
1630 "position recovery did not restore the reported quantity"
1631 };
1632
1633 Some(format!(
1634 "account={account_id}, instrument={instrument_id}, venue_position_id={:?}, venue_quantity={venue_qty}: {reason}",
1635 report.venue_position_id,
1636 ))
1637 }
1638
1639 fn position_report_prices_match(
1640 &self,
1641 cached_positions: &[Position],
1642 reports: &[PositionStatusReport],
1643 ) -> bool {
1644 for negative in [false, true] {
1645 let reports: Vec<_> = reports
1646 .iter()
1647 .filter(|report| {
1648 !report.signed_decimal_qty.is_zero()
1649 && report.signed_decimal_qty.is_sign_negative() == negative
1650 })
1651 .collect();
1652
1653 if !reports.iter().any(|report| report.avg_px_open.is_some())
1654 || reports.iter().any(|report| {
1655 report.avg_px_open_reconciliation == AvgPxReconciliation::OpeningOnly
1656 })
1657 {
1658 continue;
1659 }
1660
1661 let Some((venue_value, venue_qty)) = reports.iter().try_fold(
1662 (Decimal::ZERO, Decimal::ZERO),
1663 |(value, quantity), report| {
1664 let price = report.avg_px_open.filter(|price| *price > Decimal::ZERO)?;
1665 let qty = report.signed_decimal_qty.abs();
1666 Some((value + price * qty, quantity + qty))
1667 },
1668 ) else {
1669 return false;
1670 };
1671
1672 let positions: Vec<&Position> = cached_positions
1673 .iter()
1674 .filter(|position| {
1675 !position.quantity.is_zero()
1676 && position.signed_decimal_qty().is_sign_negative() == negative
1677 })
1678 .collect();
1679
1680 if positions
1681 .iter()
1682 .any(|position| position.avg_px_open <= Decimal::ZERO)
1683 {
1684 return false;
1685 }
1686
1687 if positions.is_empty()
1688 && venue_qty <= self.position_reconciliation_tolerance(reports[0].account_id)
1689 {
1690 continue;
1691 }
1692
1693 let Some(cached_avg_px) = position_avg_px(positions) else {
1694 return false;
1695 };
1696
1697 let venue_precision = reports
1699 .iter()
1700 .filter_map(|report| report.avg_px_open_precision)
1701 .min();
1702
1703 if !position_prices_match(
1704 cached_avg_px,
1705 venue_value / venue_qty,
1706 None,
1707 venue_precision,
1708 ) {
1709 return false;
1710 }
1711 }
1712
1713 true
1714 }
1715
1716 fn retained_fill_state(&self) -> RetainedFillState {
1717 let cache = self.cache.borrow();
1718 let positions = cache.positions(None, None, None, None, None);
1719 let mut fill_keys = IndexSet::new();
1720 let mut missing_order_ids = IndexSet::new();
1721 let mut missing_venue_order_ids = IndexSet::new();
1722 let mut netting_lifecycle_starts = IndexMap::new();
1723
1724 for position in positions {
1725 for fill in &position.events {
1726 fill_keys.insert((position.account_id, position.instrument_id, fill.trade_id));
1727 if cache.order(&fill.client_order_id).is_none() {
1728 missing_order_ids.insert((
1729 position.account_id,
1730 position.instrument_id,
1731 fill.client_order_id,
1732 ));
1733 missing_venue_order_ids.insert((
1734 position.account_id,
1735 position.instrument_id,
1736 fill.venue_order_id,
1737 ));
1738 }
1739 }
1740
1741 if cache.oms_type(&position.id) == Some(OmsType::Netting) {
1742 netting_lifecycle_starts.insert(
1743 (
1744 position.account_id,
1745 position.instrument_id,
1746 position.strategy_id,
1747 ),
1748 position.ts_opened,
1749 );
1750 }
1751 }
1752
1753 RetainedFillState {
1754 fill_keys,
1755 missing_order_ids,
1756 missing_venue_order_ids,
1757 netting_lifecycle_starts,
1758 }
1759 }
1760
1761 fn order_only_ids(
1762 &self,
1763 mass_status: &ExecutionMassStatus,
1764 order_reports: &IndexMap<VenueOrderId, OrderStatusReport>,
1765 fill_reports: &IndexMap<VenueOrderId, Vec<FillReport>>,
1766 ) -> IndexSet<VenueOrderId> {
1767 if mass_status.lookback_start().is_none() {
1768 return IndexSet::new();
1769 }
1770
1771 let reported_instruments: IndexSet<InstrumentId> = if self.config.filter_position_reports {
1772 IndexSet::new()
1773 } else {
1774 mass_status
1775 .position_reports()
1776 .into_iter()
1777 .filter(|(instrument_id, reports)| {
1778 !reports.is_empty() && self.should_reconcile_instrument(instrument_id)
1779 })
1780 .map(|(instrument_id, _)| instrument_id)
1781 .collect()
1782 };
1783
1784 let mut venue_order_ids = IndexSet::new();
1785
1786 for (venue_order_id, report) in order_reports {
1787 if report.filled_qty.is_zero() || reported_instruments.contains(&report.instrument_id) {
1788 continue;
1789 }
1790
1791 venue_order_ids.insert(*venue_order_id);
1792 }
1793
1794 for (venue_order_id, fills) in fill_reports {
1795 let Some(fill) = fills.first() else {
1796 continue;
1797 };
1798
1799 if reported_instruments.contains(&fill.instrument_id) {
1800 continue;
1801 }
1802
1803 venue_order_ids.insert(*venue_order_id);
1804 }
1805
1806 venue_order_ids
1807 }
1808
1809 fn fill_reduces_position(&self, fill: &OrderFilled, engine: &ExecutionEngine) -> bool {
1810 let Some(position_id) = engine.reconciliation_position_id(fill) else {
1811 return false;
1812 };
1813
1814 let cache = self.cache.borrow();
1815
1816 let Some(order) = cache.order(&fill.client_order_id) else {
1817 return false;
1818 };
1819
1820 if order.order_side() != fill.order_side
1821 || !matches!(has_active_inferred_fill(&order), Ok(false))
1822 {
1823 return false;
1824 }
1825
1826 cache.position_ref(&position_id).is_some_and(|position| {
1827 position.is_open()
1828 && !position.is_settled()
1829 && position.instrument_id == fill.instrument_id
1830 && position.account_id == fill.account_id
1831 && position.closing_order_side() == Some(fill.order_side)
1832 && fill.last_qty <= position.quantity
1833 && fill.ts_event >= position.ts_opened
1834 && !position.trade_ids.contains(&fill.trade_id)
1835 })
1836 }
1837
1838 fn validate_mass_status_order_sources(&self, mass_status: &ExecutionMassStatus) {
1842 let cache = self.cache.borrow();
1843 let mut checked_client_order_ids = IndexSet::new();
1844 let mut missing_origins: Vec<ClientOrderId> = Vec::new();
1845 let mut mismatched_origins: Vec<(ClientOrderId, ClientId)> = Vec::new();
1846
1847 let mut validate_report_source =
1848 |direct_client_order_id: Option<ClientOrderId>, venue_order_id: VenueOrderId| {
1849 let direct_client_order_id = direct_client_order_id
1850 .filter(|client_order_id| cache.order_exists(client_order_id));
1851 let indexed_client_order_id = cache
1852 .client_order_id(&venue_order_id)
1853 .copied()
1854 .filter(|client_order_id| cache.order_exists(client_order_id));
1855 for client_order_id in [direct_client_order_id, indexed_client_order_id]
1856 .into_iter()
1857 .flatten()
1858 .filter(|client_order_id| checked_client_order_ids.insert(*client_order_id))
1859 {
1860 match cache.client_id(&client_order_id) {
1861 Some(cached_client_id) if *cached_client_id == mass_status.client_id => {}
1862 Some(cached_client_id) => {
1863 mismatched_origins.push((client_order_id, *cached_client_id));
1864 }
1865 None => missing_origins.push(client_order_id),
1866 }
1867 }
1868 };
1869
1870 for report in mass_status.order_reports().values() {
1871 validate_report_source(report.client_order_id, report.venue_order_id);
1872 }
1873
1874 for fills in mass_status.fill_reports().values() {
1875 for fill in fills {
1876 validate_report_source(fill.client_order_id, fill.venue_order_id);
1877 }
1878 }
1879
1880 if !missing_origins.is_empty() {
1881 let samples = missing_origins
1882 .iter()
1883 .take(LOG_SAMPLES_MAX)
1884 .map(ToString::to_string)
1885 .collect::<Vec<_>>()
1886 .join(", ");
1887
1888 log::warn!(
1889 "Found {} cached order(s) without an execution client origin ({}): \
1890 continuing reconciliation against mass status client {} for compatibility \
1891 with existing cache data",
1892 missing_origins.len(),
1893 samples,
1894 mass_status.client_id,
1895 );
1896 }
1897
1898 if !mismatched_origins.is_empty() {
1899 let samples = mismatched_origins
1900 .iter()
1901 .take(LOG_SAMPLES_MAX)
1902 .map(|(client_order_id, cached)| format!("{client_order_id} -> {cached}"))
1903 .collect::<Vec<_>>()
1904 .join(", ");
1905
1906 log::warn!(
1907 "Found {} cached order(s) with an execution client origin conflicting with \
1908 mass status client {} ({}): continuing reconciliation for compatibility; \
1909 this conflict will become a startup error in a future release, verify cached \
1910 order ownership and execution client configuration",
1911 mismatched_origins.len(),
1912 mass_status.client_id,
1913 samples,
1914 );
1915 }
1916 }
1917
1918 pub fn check_inflight_orders(&mut self) -> InflightCheckResult {
1925 let mut result = InflightCheckResult::default();
1926 let now = dst::time::Instant::now();
1927 let threshold = Duration::from_millis(self.config().inflight_threshold_ms);
1928
1929 let mut to_check = Vec::new();
1930
1931 for (client_order_id, check) in &self.order_inflight_checks {
1932 if now
1933 .checked_duration_since(check.submitted_at)
1934 .is_some_and(|elapsed| elapsed > threshold)
1935 {
1936 to_check.push(*client_order_id);
1937 }
1938 }
1939
1940 for client_order_id in to_check {
1941 self.confirm_submission_outcome(&client_order_id);
1942 if self
1943 .config
1944 .filtered_client_order_ids
1945 .contains(&client_order_id)
1946 {
1947 self.clear_recon_tracking(&client_order_id, true);
1948 continue;
1949 }
1950
1951 if self.order_query_pending.contains(&client_order_id) {
1952 continue;
1953 }
1954
1955 let Some(check) = self.order_inflight_checks.get_mut(&client_order_id) else {
1956 continue;
1957 };
1958
1959 if let Some(last_query_at) = check.last_query_at
1960 && now
1961 .checked_duration_since(last_query_at)
1962 .is_none_or(|elapsed| elapsed < threshold)
1963 {
1964 continue;
1965 }
1966
1967 check.retry_count += 1;
1968 check.last_query_at = Some(now);
1969 self.order_query_recency.mark(client_order_id);
1970 self.order_recon_retries
1971 .insert(client_order_id, check.retry_count);
1972 if check.retry_count >= self.config.inflight_max_retries {
1973 let retry_count = check.retry_count;
1974
1975 if self.exhaust_submission(
1976 client_order_id,
1977 SubmissionRecoverySource::Inflight,
1978 retry_count,
1979 ) {
1980 continue;
1981 }
1982
1983 let ts_now = self.clock.borrow().timestamp_ns();
1984
1985 if let Some(order) = self.get_order(client_order_id) {
1986 match order.status() {
1987 OrderStatus::Submitted => {
1988 if let Some(event) = create_reconciliation_rejected(
1990 &order,
1991 Some("INFLIGHT_TIMEOUT"),
1992 ts_now,
1993 ) {
1994 result.events.push(event);
1995 }
1996 }
1997 OrderStatus::PendingUpdate | OrderStatus::PendingCancel => {
1998 result
2000 .events
2001 .push(create_reconciliation_canceled(&order, ts_now));
2002 }
2003 _ => {
2004 }
2006 }
2007 }
2008
2009 self.clear_recon_tracking(&client_order_id, true);
2010 } else if let Some(order) = self.get_order(client_order_id) {
2011 let ts_now = self.clock.borrow().timestamp_ns();
2013 let client_id = self.cache.borrow().client_id(&client_order_id).copied();
2014 let query = TradingCommand::QueryOrder(QueryOrder::new(
2015 order.trader_id(),
2016 client_id,
2017 order.strategy_id(),
2018 order.instrument_id(),
2019 order.client_order_id(),
2020 order.venue_order_id(),
2021 UUID4::new(),
2022 ts_now,
2023 None,
2024 None, ));
2026 result.queries.push(query);
2027 }
2028 }
2029
2030 result
2031 }
2032
2033 pub(crate) fn register_submission_retention(&mut self, client: &dyn ExecutionClient) {
2034 if client.retain_unresolved_submissions() {
2035 self.submission_retention
2036 .insert(client.client_id(), client.account_id());
2037 }
2038 }
2039
2040 fn submission_retention_enabled(
2041 &self,
2042 client_order_id: ClientOrderId,
2043 client_id: Option<ClientId>,
2044 ) -> bool {
2045 if self.config.submission_recovery_policy == SubmissionRecoveryPolicy::RetainUnresolved {
2046 return true;
2047 }
2048
2049 if self.submission_retention.is_empty() {
2050 return false;
2051 }
2052
2053 let cache = self.cache.borrow();
2054
2055 if let Some(client_id) = client_id.or_else(|| cache.client_id(&client_order_id).copied()) {
2056 return self.submission_retention.contains_key(&client_id);
2057 }
2058
2059 cache
2060 .order_ref(&client_order_id)
2061 .and_then(|order| order.account_id())
2062 .is_some_and(|account_id| {
2063 self.submission_retention
2064 .values()
2065 .any(|id| *id == account_id)
2066 })
2067 }
2068
2069 fn submission_is_retained(&self, client_order_id: ClientOrderId) -> bool {
2070 self.submissions
2071 .get(&client_order_id)
2072 .is_some_and(|submission| submission.exhausted)
2073 && self.submission_recovery_pending(client_order_id)
2074 }
2075
2076 fn filtered_open_orders_for_reconciliation(&self) -> Vec<OrderAny> {
2077 let cache = self.cache.borrow();
2078 let mut orders = cache.orders_open(None, None, None, None, None);
2079 orders.extend(cache.orders_inflight(None, None, None, None, None));
2080 let mut seen_client_order_ids = IndexSet::new();
2081 orders
2082 .into_iter()
2083 .filter(|order| {
2084 seen_client_order_ids.insert(order.client_order_id())
2085 && !self.submission_is_retained(order.client_order_id())
2086 && !self
2087 .config
2088 .filtered_client_order_ids
2089 .contains(&order.client_order_id())
2090 && self.should_reconcile_instrument(&order.instrument_id())
2091 })
2092 .map(|order| order.clone())
2093 .collect()
2094 }
2095
2096 fn open_position_keys_for_reconciliation(&self) -> IndexSet<InstrumentAccountKey> {
2097 let cache = self.cache.borrow();
2098 let positions = cache.positions_open(None, None, None, None, None);
2099 let mut position_keys = IndexSet::new();
2100
2101 for position in positions {
2102 if !self.should_reconcile_instrument(&position.instrument_id) {
2103 continue;
2104 }
2105
2106 position_keys.insert((position.instrument_id, position.account_id));
2107 }
2108
2109 position_keys
2110 }
2111
2112 pub async fn check_open_orders(
2116 &mut self,
2117 clients: &[&dyn ExecutionClient],
2118 ) -> Vec<OrderEventAny> {
2119 log::debug!("Checking order consistency between cached-state and venues");
2120
2121 let check = self.prepare_open_order_report_check(UUID4::new(), clients);
2122 let mut all_reports = Vec::new();
2123 let mut queried_clients = IndexSet::new();
2124 let mut failed_clients = IndexSet::new();
2125
2126 for client in clients {
2127 let client_id = client.client_id();
2128 queried_clients.insert(client_id);
2129
2130 match client.generate_order_status_reports(&check.command).await {
2131 Ok(reports) => {
2132 all_reports.extend(
2133 reports
2134 .into_iter()
2135 .map(|report| SourcedOrderStatusReport { client_id, report }),
2136 );
2137 }
2138 Err(e) => {
2139 failed_clients.insert(client_id);
2140 log::warn!("Failed to query order reports from {client_id}: {e}");
2141 }
2142 }
2143 }
2144
2145 let result = self.reconcile_open_order_reports(
2146 &check,
2147 all_reports,
2148 &queried_clients,
2149 &failed_clients,
2150 clients,
2151 );
2152
2153 let mut events = result.events;
2154
2155 if !result.targeted_queries.is_empty() {
2156 let query_delay =
2157 Duration::from_millis(u64::from(self.config.single_order_query_delay_ms));
2158 let query_results =
2159 request_targeted_order_reports(result.targeted_queries, clients, query_delay).await;
2160 events.extend(self.reconcile_targeted_order_reports(query_results, clients));
2161 }
2162
2163 events
2164 }
2165
2166 pub(crate) fn prepare_open_order_report_check(
2168 &mut self,
2169 command_id: UUID4,
2170 clients: &[&dyn ExecutionClient],
2171 ) -> OpenOrderReportCheck {
2172 for client in clients {
2173 self.register_submission_retention(*client);
2174 }
2175
2176 let filtered_orders = self.filtered_open_orders_for_reconciliation();
2177 let active_order_ids: IndexSet<ClientOrderId> =
2178 filtered_orders.iter().map(Order::client_order_id).collect();
2179 self.order_coverage_warnings
2180 .retain(|client_order_id| active_order_ids.contains(client_order_id));
2181 self.order_lookback_warnings
2182 .retain(|client_order_id| active_order_ids.contains(client_order_id));
2183 self.order_coverage_unresolved
2184 .retain(|client_order_id| active_order_ids.contains(client_order_id));
2185
2186 let mut client_coverage = IndexMap::new();
2187
2188 for order in &filtered_orders {
2189 let client_order_id = order.client_order_id();
2190 let coverage = self.resolve_order_report_client_coverage(order, clients);
2191
2192 match &coverage {
2193 ReportClientCoverage::Resolved(_) => {
2194 if self
2195 .order_coverage_unresolved
2196 .shift_remove(&client_order_id)
2197 {
2198 self.order_coverage_warnings.shift_remove(&client_order_id);
2199 }
2200 }
2201 ReportClientCoverage::Unavailable(_) | ReportClientCoverage::Unresolved => {
2202 self.order_coverage_unresolved.insert(client_order_id);
2203 }
2204 }
2205
2206 client_coverage.insert(client_order_id, coverage);
2207 }
2208
2209 log::debug!(
2210 "Found {} order{} open in cache",
2211 filtered_orders.len(),
2212 if filtered_orders.len() == 1 { "" } else { "s" }
2213 );
2214
2215 let ts_now = self.clock.borrow().timestamp_ns();
2216 let start = self
2217 .config
2218 .open_check_lookback_mins
2219 .map(DurationNanos::from_mins)
2220 .map(|lookback| ts_now.saturating_sub(lookback));
2221
2222 let mut command = GenerateOrderStatusReports::new(
2223 command_id,
2224 ts_now,
2225 self.config.open_check_open_only,
2226 None,
2227 start,
2228 None,
2229 None,
2230 None,
2231 );
2232 command.log_receipt_level = LogLevel::Debug;
2233
2234 OpenOrderReportCheck {
2235 command,
2236 filtered_orders,
2237 client_coverage,
2238 }
2239 }
2240
2241 fn resolve_order_report_client_coverage(
2242 &self,
2243 order: &OrderAny,
2244 clients: &[&dyn ExecutionClient],
2245 ) -> ReportClientCoverage {
2246 if let Some(client_id) = self.cache.borrow().client_id(&order.client_order_id()) {
2247 return ReportClientCoverage::Resolved(IndexSet::from([*client_id]));
2248 }
2249
2250 let client_ids =
2251 responsible_client_ids(order.account_id(), order.instrument_id().venue, clients);
2252
2253 if client_ids.is_empty() {
2254 ReportClientCoverage::Unresolved
2255 } else {
2256 ReportClientCoverage::Resolved(client_ids)
2257 }
2258 }
2259
2260 pub fn check_open_order_queries(&mut self) -> Vec<TradingCommand> {
2262 let now = dst::time::Instant::now();
2263 let query_delay = Duration::from_millis(u64::from(self.config.single_order_query_delay_ms));
2264 let query_limit = self.config.max_single_order_queries_per_cycle as usize;
2265
2266 if query_limit == 0 {
2267 return Vec::new();
2268 }
2269
2270 let mut filtered_orders = self.filtered_open_orders_for_reconciliation();
2271 filtered_orders.sort_by_key(|order| {
2272 let client_order_id = order.client_order_id();
2273 (
2274 self.order_query_recency.last_marked(&client_order_id),
2275 client_order_id,
2276 )
2277 });
2278
2279 let mut queries = Vec::new();
2280 for order in filtered_orders {
2281 if queries.len() >= query_limit {
2282 break;
2283 }
2284
2285 let client_order_id = order.client_order_id();
2286 let threshold = Duration::from(self.config.open_check_threshold_ns);
2287
2288 if let Some(elapsed) = self.order_activity.elapsed_at(&client_order_id, now)
2289 && elapsed < threshold
2290 {
2291 let elapsed_ms = elapsed.as_millis();
2292 let threshold_ms = threshold.as_millis();
2293 log::debug!(
2294 "Deferring open order query for {client_order_id}: recent local activity \
2295 ({elapsed_ms}ms < threshold={threshold_ms}ms)",
2296 );
2297 continue;
2298 }
2299
2300 if self
2301 .order_query_recency
2302 .within_at(&client_order_id, now, query_delay)
2303 {
2304 continue;
2305 }
2306
2307 self.order_query_recency.mark(client_order_id);
2308 let client_id = self.cache.borrow().client_id(&client_order_id).copied();
2309 let ts_now = self.clock.borrow().timestamp_ns();
2310
2311 let cmd = TradingCommand::QueryOrder(QueryOrder::new(
2312 order.trader_id(),
2313 client_id,
2314 order.strategy_id(),
2315 order.instrument_id(),
2316 client_order_id,
2317 order.venue_order_id(),
2318 UUID4::new(),
2319 ts_now,
2320 None,
2321 None,
2322 ));
2323 queries.push(cmd);
2324 }
2325
2326 queries
2327 }
2328
2329 pub(crate) fn reconcile_open_order_reports(
2331 &mut self,
2332 check: &OpenOrderReportCheck,
2333 mut all_reports: Vec<SourcedOrderStatusReport>,
2334 queried_clients: &IndexSet<ClientId>,
2335 failed_clients: &IndexSet<ClientId>,
2336 clients: &[&dyn ExecutionClient],
2337 ) -> OpenOrderReconciliationResult {
2338 all_reports.retain(|sourced| !self.should_skip_order_report(&sourced.report));
2339 let mut venue_reported_ids = IndexSet::new();
2340
2341 for sourced in &all_reports {
2342 let report = &sourced.report;
2343
2344 let client_order_id = report.client_order_id.or_else(|| {
2345 self.cache
2346 .borrow()
2347 .client_order_id(&report.venue_order_id)
2348 .copied()
2349 });
2350
2351 let Some(client_order_id) = client_order_id else {
2352 continue;
2353 };
2354
2355 venue_reported_ids.insert(client_order_id);
2356 self.order_coverage_warnings.shift_remove(&client_order_id);
2357 self.order_lookback_warnings.shift_remove(&client_order_id);
2358
2359 self.order_recon_retries.shift_remove(&client_order_id);
2363 }
2364
2365 let mut events = Vec::new();
2366 let mut targeted_candidates = Vec::new();
2367
2368 for sourced in all_reports {
2369 let report = sourced.report;
2370
2371 let order = match report.client_order_id {
2372 Some(client_order_id) => self.get_order(client_order_id),
2373 None => self.get_order_by_venue_order_id(report.venue_order_id),
2374 };
2375
2376 let Some(order) = order else {
2377 continue;
2378 };
2379
2380 let client_order_id = order.client_order_id();
2381
2382 let threshold = Duration::from(self.config.open_check_threshold_ns);
2384 let activity_elapsed = self.order_activity.elapsed(&client_order_id);
2385 self.confirm_submitted_report(&report);
2386
2387 if let Some(elapsed) = activity_elapsed
2388 && elapsed < threshold
2389 {
2390 let elapsed_ms = elapsed.as_millis();
2391 let threshold_ms = threshold.as_millis();
2392 log::debug!(
2393 "Deferring reconciliation for {client_order_id}: recent local activity ({elapsed_ms}ms < threshold={threshold_ms}ms)",
2394 );
2395 continue;
2396 }
2397
2398 let instrument = self.get_instrument(&report.instrument_id);
2399
2400 let commission_client = clients
2401 .iter()
2402 .find(|client| client.client_id() == sourced.client_id)
2403 .copied();
2404
2405 if order_report_has_missing_fills(
2406 &report,
2407 order.filled_qty(),
2408 commission_client.is_some_and(ExecutionClient::requires_authoritative_fills),
2409 ) {
2410 targeted_candidates.push((
2411 order,
2412 IndexSet::from([sourced.client_id]),
2413 Some(report),
2414 ));
2415 continue;
2416 }
2417
2418 match self.reconcile_order_report(
2419 &order,
2420 &report,
2421 instrument.as_ref(),
2422 commission_client,
2423 ) {
2424 Ok(order_events) => events.extend(order_events),
2425 Err(e) => log::error!(
2426 "Deferring reconciliation for {client_order_id}: order reconciliation failed: {e}"
2427 ),
2428 }
2429 }
2430
2431 if self.config.open_check_open_only {
2436 let cached_ids: IndexSet<ClientOrderId> = check
2437 .filtered_orders
2438 .iter()
2439 .map(Order::client_order_id)
2440 .collect();
2441 let missing_at_venue: IndexSet<ClientOrderId> = cached_ids
2442 .difference(&venue_reported_ids)
2443 .copied()
2444 .collect();
2445
2446 if !missing_at_venue.is_empty() {
2447 log::debug!(
2448 "{} cached open order{} not present in venue current response",
2449 missing_at_venue.len(),
2450 if missing_at_venue.len() == 1 {
2451 " is"
2452 } else {
2453 "s are"
2454 },
2455 );
2456
2457 for client_order_id in missing_at_venue {
2458 log::debug!("Cached open order missing from venue response: {client_order_id}");
2459 }
2460 }
2461 } else {
2462 let candidates: Vec<&OrderAny> = if let Some(cutoff) = check.command.start {
2463 let mut candidates = Vec::new();
2464
2465 for order in &check.filtered_orders {
2466 let client_order_id = order.client_order_id();
2467 if order.ts_last() >= cutoff {
2468 self.order_lookback_warnings.shift_remove(&client_order_id);
2469 candidates.push(order);
2470 } else if !venue_reported_ids.contains(&client_order_id)
2471 && self.order_lookback_warnings.insert(client_order_id)
2472 {
2473 log::warn!(
2474 "Skipping missing-order reconciliation for {client_order_id}: its last update predates the configured open-check lookback window; absence from the bulk response cannot be treated as evidence and no targeted query will be issued from it"
2475 );
2476 }
2477 }
2478
2479 candidates
2480 } else {
2481 check.filtered_orders.iter().collect()
2482 };
2483
2484 for order in candidates {
2485 let client_order_id = order.client_order_id();
2486 if venue_reported_ids.contains(&client_order_id) {
2487 continue;
2488 }
2489
2490 let responsible_clients = match check.client_coverage.get(&client_order_id) {
2491 Some(ReportClientCoverage::Resolved(responsible_clients))
2492 if !responsible_clients.is_empty() =>
2493 {
2494 responsible_clients
2495 }
2496 _ => {
2497 if self.order_coverage_warnings.insert(client_order_id) {
2498 log::warn!(
2499 "Skipping order reconciliation for {client_order_id}: responsible execution client coverage is unresolved"
2500 );
2501 }
2502
2503 continue;
2504 }
2505 };
2506
2507 let missing_clients = responsible_clients
2508 .difference(queried_clients)
2509 .copied()
2510 .collect::<IndexSet<_>>();
2511
2512 if !missing_clients.is_empty() {
2513 if self.order_coverage_warnings.insert(client_order_id) {
2514 log::warn!(
2515 "Skipping order reconciliation for {client_order_id}: responsible execution clients were not queried: {missing_clients:?}"
2516 );
2517 }
2518
2519 continue;
2520 }
2521
2522 let failed_responsible_clients = responsible_clients
2523 .intersection(failed_clients)
2524 .copied()
2525 .collect::<IndexSet<_>>();
2526
2527 if !failed_responsible_clients.is_empty() {
2528 log::warn!(
2529 "Skipping order reconciliation for {client_order_id}: failed to query responsible execution clients: {failed_responsible_clients:?}"
2530 );
2531 continue;
2532 }
2533
2534 self.order_coverage_warnings.shift_remove(&client_order_id);
2535 if let Some(order) = self.prepare_missing_order_query(client_order_id) {
2536 targeted_candidates.push((order, responsible_clients.clone(), None));
2537 }
2538 }
2539 }
2540
2541 targeted_candidates.sort_by_key(|(order, _, _)| {
2542 let client_order_id = order.client_order_id();
2543 (
2544 self.order_query_recency.last_marked(&client_order_id),
2545 client_order_id,
2546 )
2547 });
2548
2549 let query_limit = self.config.max_single_order_queries_per_cycle as usize;
2550 let mut planned_queries = 0usize;
2551 let mut cap_deferred_orders = 0usize;
2552 let mut targeted_queries = Vec::new();
2553
2554 for (order, responsible_clients, report) in targeted_candidates {
2555 let client_order_id = order.client_order_id();
2556
2557 let required_queries = responsible_clients.len();
2558 let exceeds_query_limit = planned_queries + required_queries > query_limit;
2559 let can_run_oversized_group = planned_queries == 0 && query_limit > 0;
2560 if required_queries == 0 || (exceeds_query_limit && !can_run_oversized_group) {
2561 cap_deferred_orders += 1;
2562 continue;
2563 }
2564
2565 if required_queries > query_limit {
2566 log::warn!(
2567 "Targeted order query for {client_order_id} requires {required_queries} responsible clients, exceeding the per-cycle limit {query_limit} to avoid indefinite deferral"
2568 );
2569 }
2570
2571 planned_queries += required_queries;
2572 self.order_query_recency.mark(client_order_id);
2573 self.order_query_pending.insert(client_order_id);
2574 let command_id = UUID4::new();
2575 let ts_now = self.clock.borrow().timestamp_ns();
2576
2577 let command = GenerateOrderStatusReport::new(
2578 command_id,
2579 ts_now,
2580 Some(order.instrument_id()),
2581 Some(client_order_id),
2582 order.venue_order_id(),
2583 None,
2584 None,
2585 );
2586 targeted_queries.push(TargetedOrderQuery {
2587 client_order_id,
2588 responsible_clients,
2589 report,
2590 filled_qty: order.filled_qty(),
2591 command,
2592 });
2593 }
2594
2595 if cap_deferred_orders > 0 {
2596 log::warn!(
2597 "Reached max single-order queries ({query_limit}) this cycle, deferring {cap_deferred_orders} order(s)"
2598 );
2599 }
2600
2601 OpenOrderReconciliationResult {
2602 events,
2603 targeted_queries,
2604 }
2605 }
2606
2607 pub(crate) fn reconcile_targeted_order_reports(
2609 &mut self,
2610 results: Vec<TargetedOrderReportResult>,
2611 clients: &[&dyn ExecutionClient],
2612 ) -> Vec<OrderEventAny> {
2613 let mut events = Vec::new();
2614 let mut fill_queue = ReconciliationFillQueue::default();
2615
2616 for result in results {
2617 let client_order_id = result.client_order_id;
2618 self.remove_targeted_order_queries(&[client_order_id]);
2619 if let Some(report) = result.report {
2620 self.order_recon_retries.shift_remove(&client_order_id);
2621 self.order_coverage_warnings.shift_remove(&client_order_id);
2622
2623 let Some(order) = self.get_order(client_order_id) else {
2624 continue;
2625 };
2626
2627 let instrument = self.get_instrument(&report.instrument_id);
2628
2629 let commission_client = result.client_id.and_then(|client_id| {
2630 clients
2631 .iter()
2632 .find(|client| client.client_id() == client_id)
2633 .copied()
2634 });
2635
2636 log::info!(
2637 color = LogColor::Blue as u8;
2638 "Found {client_order_id} via targeted order status query: {}",
2639 report.order_status,
2640 );
2641
2642 let fills = result.fills.iter().collect::<Vec<_>>();
2643 events.extend(self.reconcile_order_with_fills(
2644 false,
2645 &order,
2646 &report,
2647 &fills,
2648 instrument.as_ref(),
2649 &mut fill_queue,
2650 commission_client,
2651 ));
2652 continue;
2653 }
2654
2655 if result.coverage_complete {
2656 events.extend(self.resolve_missing_order(client_order_id));
2657 } else {
2658 log::warn!(
2659 "Deferring missing-order resolution for {client_order_id}: targeted order status coverage was incomplete"
2660 );
2661 }
2662 }
2663
2664 sort_reconciliation_events(&mut events);
2665 events
2666 }
2667
2668 pub async fn check_positions_consistency(
2673 &mut self,
2674 clients: &[&dyn ExecutionClient],
2675 ) -> Vec<OrderEventAny> {
2676 let check = self.prepare_position_report_check(UUID4::new(), clients);
2677 let mut reports = Vec::new();
2678 let mut queried_clients = IndexSet::new();
2679 let mut failed_clients = IndexSet::new();
2680
2681 for client in clients {
2682 let client_id = client.client_id();
2683 queried_clients.insert(client_id);
2684 self.set_position_reconciliation_tolerance(
2685 client.account_id(),
2686 client.position_reconciliation_tolerance(),
2687 );
2688
2689 match client
2690 .generate_position_status_reports(&check.command)
2691 .await
2692 {
2693 Ok(client_reports) => {
2694 reports.extend(client_reports);
2695 }
2696 Err(e) => {
2697 failed_clients.insert(client_id);
2698 log::warn!("Failed to query position reports from {client_id}: {e}");
2699 }
2700 }
2701 }
2702
2703 let active_keys = self
2704 .open_position_keys_for_reconciliation()
2705 .into_iter()
2706 .chain(reports.iter().filter_map(|report| {
2707 (self.should_reconcile_instrument(&report.instrument_id)
2708 && report.signed_decimal_qty != Decimal::ZERO)
2709 .then_some((report.instrument_id, report.account_id))
2710 }))
2711 .collect();
2712
2713 let events =
2714 self.reconcile_position_reports(&check, reports, &queried_clients, &failed_clients);
2715
2716 self.retain_position_reconciliation(&active_keys);
2718
2719 events
2720 }
2721
2722 #[must_use]
2727 pub fn prepare_position_report_check(
2728 &self,
2729 command_id: UUID4,
2730 clients: &[&dyn ExecutionClient],
2731 ) -> PositionReportCheck {
2732 let position_keys = self.open_position_keys_for_reconciliation();
2733
2734 let client_coverage = position_keys
2735 .iter()
2736 .map(|key| (*key, resolve_position_report_client_coverage(*key, clients)))
2737 .collect();
2738
2739 let mut activity_revisions = self.position_activity_revisions.clone();
2740 for key in &position_keys {
2741 activity_revisions
2742 .entry(*key)
2743 .or_insert_with(|| self.position_activity_revision(key));
2744 }
2745
2746 log::debug!(
2747 "Found {} unique instrument/account combination{} with open positions",
2748 position_keys.len(),
2749 if position_keys.len() == 1 { "" } else { "s" }
2750 );
2751
2752 let ts_now = self.clock.borrow().timestamp_ns();
2753
2754 let mut command = GeneratePositionStatusReports::new(
2755 command_id, ts_now, None, None, None, None, None, );
2761 command.log_receipt_level = LogLevel::Debug;
2762
2763 PositionReportCheck {
2764 command,
2765 client_coverage,
2766 activity_revisions,
2767 }
2768 }
2769
2770 pub fn plan_position_fill_reports(
2775 &mut self,
2776 check: &mut PositionReportCheck,
2777 reports: &[PositionStatusReport],
2778 queried_clients: &IndexSet<ClientId>,
2779 failed_clients: &IndexSet<ClientId>,
2780 clients: &[&dyn ExecutionClient],
2781 ) -> PositionFillReportPlan {
2782 let venue_positions = self.group_position_reports(reports.iter().cloned());
2783
2784 let keys = check
2785 .client_coverage
2786 .keys()
2787 .copied()
2788 .chain(venue_positions.iter().filter_map(|(key, reports)| {
2789 reports
2790 .iter()
2791 .any(|report| report.signed_decimal_qty != Decimal::ZERO)
2792 .then_some(*key)
2793 }))
2794 .collect::<IndexSet<_>>();
2795
2796 let query_end = self.timestamp_ns();
2797 let lookback = DurationNanos::from_mins(self.config.position_check_lookback_mins);
2798 let query_start = query_end.saturating_sub(lookback);
2799 let mut discrepancy_keys = IndexSet::new();
2800 let mut queries = Vec::new();
2801
2802 for &key in &keys {
2803 let coverage = check
2804 .client_coverage
2805 .entry(key)
2806 .or_insert_with(|| resolve_position_report_client_coverage(key, clients));
2807 let prepared_revision = *check.activity_revisions.entry(key).or_default();
2808 let venue_reports = venue_positions
2809 .get(&key)
2810 .map(Vec::as_slice)
2811 .unwrap_or_default();
2812 let comparison = self.position_quantity_comparison(key, venue_reports);
2813 let tolerance = self.position_reconciliation_tolerance(key.1);
2814 if comparison.quantities_match(tolerance) {
2815 self.clear_position_reconciliation(&key);
2816 continue;
2817 }
2818
2819 discrepancy_keys.insert(key);
2820
2821 if self.position_activity_revision(&key) > prepared_revision
2822 || self.position_activity_is_recent(&key)
2823 {
2824 continue;
2825 }
2826
2827 let report_shape = comparison.report_shape();
2828 let retries = self.position_reconciliation_retries(&key, report_shape);
2829 if retries >= self.config().position_check_retries {
2830 continue;
2831 }
2832
2833 let responsible_clients = match coverage {
2834 ReportClientCoverage::Resolved(responsible_clients) => responsible_clients,
2835
2836 ReportClientCoverage::Unavailable(responsible_clients)
2838 if !venue_reports.is_empty() =>
2839 {
2840 responsible_clients
2841 }
2842 ReportClientCoverage::Unavailable(_) => {
2843 log::debug!(
2844 "Skipping fill report query for {}/{}: responsible execution client coverage is unavailable",
2845 key.0,
2846 key.1,
2847 );
2848 continue;
2849 }
2850 ReportClientCoverage::Unresolved => {
2851 log::warn!(
2852 "Skipping fill report query for {}/{}: responsible execution client coverage is unresolved",
2853 key.0,
2854 key.1,
2855 );
2856 continue;
2857 }
2858 };
2859
2860 if responsible_clients.is_empty()
2861 || !responsible_clients.is_subset(queried_clients)
2862 || !responsible_clients.is_disjoint(failed_clients)
2863 {
2864 log::warn!(
2865 "Skipping fill report query for {}/{}: responsible position report coverage is incomplete",
2866 key.0,
2867 key.1,
2868 );
2869 continue;
2870 }
2871
2872 for client_id in responsible_clients.iter() {
2873 let mut command = GenerateFillReports::new(
2874 UUID4::new(),
2875 query_end,
2876 Some(key.0),
2877 None,
2878 Some(query_start),
2879 Some(query_end),
2880 None,
2881 Some(check.command.command_id),
2882 );
2883 command.log_receipt_level = LogLevel::Debug;
2884 queries.push(PositionFillReportQuery {
2885 key,
2886 client_id: *client_id,
2887 command,
2888 });
2889 }
2890 }
2891
2892 self.retain_position_reconciliation(&keys);
2893
2894 PositionFillReportPlan {
2895 queries,
2896 discrepancy_keys,
2897 }
2898 }
2899
2900 #[must_use]
2902 pub fn position_report_check_is_current(
2903 &self,
2904 check: &PositionReportCheck,
2905 key: &InstrumentAccountKey,
2906 ) -> bool {
2907 check
2908 .activity_revisions
2909 .get(key)
2910 .is_some_and(|revision| self.position_activity_revision(key) == *revision)
2911 }
2912
2913 pub fn prepare_position_fill_report(
2920 &self,
2921 report: &mut FillReport,
2922 venue_reports: &[PositionStatusReport],
2923 ) -> anyhow::Result<PositionFillReportPreparation> {
2924 let cache = self.cache();
2925 let venue_client_order_id = cache.client_order_id(&report.venue_order_id).copied();
2926
2927 if let (Some(report_client_order_id), Some(venue_client_order_id)) =
2928 (report.client_order_id, venue_client_order_id)
2929 {
2930 anyhow::ensure!(
2931 report_client_order_id == venue_client_order_id,
2932 "fill {} client order ID {report_client_order_id} conflicts with venue order mapping {venue_client_order_id}",
2933 report.trade_id,
2934 );
2935 }
2936
2937 let client_order_id = report.client_order_id.or(venue_client_order_id);
2938 let order = client_order_id.and_then(|id| cache.order(&id));
2939 if let Some(order) = &order {
2940 anyhow::ensure!(
2941 order.instrument_id() == report.instrument_id
2942 && order.order_side() == report.order_side
2943 && order
2944 .account_id()
2945 .is_none_or(|account_id| account_id == report.account_id)
2946 && order
2947 .venue_order_id()
2948 .is_none_or(|venue_order_id| venue_order_id == report.venue_order_id),
2949 "fill {} conflicts with cached order {}",
2950 report.trade_id,
2951 order.client_order_id(),
2952 );
2953 }
2954
2955 let hedge_context = report.venue_position_id.is_some()
2956 || venue_reports
2957 .iter()
2958 .any(|venue_report| venue_report.venue_position_id.is_some());
2959 let flip = client_order_id
2960 .map(|id| cache.hedging_flip_position_ids(id))
2961 .transpose()?
2962 .flatten();
2963
2964 let mapped_position_id = flip.map(|ids| ids[1]).or_else(|| {
2965 client_order_id
2966 .and_then(|client_order_id| cache.position_id(&client_order_id))
2967 .copied()
2968 });
2969
2970 if hedge_context
2971 && let (Some(venue_position_id), Some(mapped_position_id)) =
2972 (report.venue_position_id, mapped_position_id)
2973 {
2974 anyhow::ensure!(
2975 venue_position_id == mapped_position_id
2976 || flip.is_some_and(|ids| ids.contains(&venue_position_id)),
2977 "fill {} position ID {venue_position_id} conflicts with cached order position {mapped_position_id}",
2978 report.trade_id,
2979 );
2980 }
2981
2982 if let Some(order) = order
2983 && has_active_inferred_fill(&order)?
2984 {
2985 return Ok(PositionFillReportPreparation::InferredOverlap);
2986 }
2987
2988 if fill_precedes_snapshot_reconciled_position(&cache, report) {
2989 return Ok(PositionFillReportPreparation::SnapshotOverlap);
2990 }
2991
2992 if report.venue_position_id.is_none() && flip.is_some() {
2993 report.venue_position_id = mapped_position_id;
2994 return Ok(PositionFillReportPreparation::Ready);
2995 }
2996
2997 if !hedge_context {
2998 return Ok(PositionFillReportPreparation::Ready);
2999 }
3000
3001 if report.venue_position_id.is_some() {
3002 return Ok(PositionFillReportPreparation::Ready);
3003 }
3004
3005 let Some(position_id) = mapped_position_id else {
3006 return Ok(PositionFillReportPreparation::Unattributed);
3007 };
3008
3009 let position = cache.position(&position_id).ok_or_else(|| {
3010 anyhow::anyhow!(
3011 "fill {} maps to position {position_id}, which is not cached",
3012 report.trade_id,
3013 )
3014 })?;
3015
3016 anyhow::ensure!(
3017 position.account_id == report.account_id
3018 && position.instrument_id == report.instrument_id,
3019 "fill {} maps to position {position_id} with a different account or instrument",
3020 report.trade_id,
3021 );
3022 anyhow::ensure!(
3023 position.is_open(),
3024 "fill {} maps to non-open position {position_id}",
3025 report.trade_id,
3026 );
3027 anyhow::ensure!(
3028 !position.is_opposite_side(report.order_side) || report.last_qty <= position.quantity,
3029 "fill {} without a venue position ID would cross position {position_id}",
3030 report.trade_id,
3031 );
3032
3033 report.venue_position_id = Some(position_id);
3034 Ok(PositionFillReportPreparation::Ready)
3035 }
3036
3037 pub fn record_unapplied_fill_report(&mut self, report: &FillReport) {
3039 let fill_key = (report.account_id, report.instrument_id, report.trade_id);
3040 if !self.fills_unapplied.contains_key(&fill_key) {
3041 self.fills_unapplied.mark(fill_key);
3042 }
3043
3044 let ttl = Duration::from_mins(self.config.position_check_lookback_mins)
3045 .max(Duration::from_mins(1));
3046 self.fills_unapplied.prune_older_than(ttl);
3047 }
3048
3049 #[must_use]
3053 pub fn is_unapplied_fill_report_expired(&self, report: &FillReport) -> bool {
3054 let fill_key = (report.account_id, report.instrument_id, report.trade_id);
3055 self.fills_unapplied.contains_key(&fill_key)
3056 && !self.fills_unapplied.within(
3057 &fill_key,
3058 Duration::from(self.config.position_check_threshold_ns),
3059 )
3060 }
3061
3062 #[must_use]
3064 pub fn position_contains_fill_report(&self, report: &FillReport) -> bool {
3065 let cache = self.cache();
3066 let positions = cache.positions_refs(
3067 None,
3068 Some(&report.instrument_id),
3069 None,
3070 Some(&report.account_id),
3071 None,
3072 );
3073 position_fill_report_matches(
3074 &cache,
3075 report,
3076 &positions,
3077 |id| cache.hedging_flip_position_ids(id),
3078 None,
3079 )
3080 }
3081
3082 #[cfg(feature = "node")]
3086 pub(crate) fn position_fill_reports_contained_prefix(&self, reports: &[FillReport]) -> usize {
3087 let Some(first) = reports.first() else {
3088 return 0;
3089 };
3090
3091 if reports.len() == 1 {
3092 return usize::from(self.position_contains_fill_report(first));
3093 }
3094
3095 let cache = self.cache();
3096 let positions = cache.positions_refs(
3097 None,
3098 Some(&first.instrument_id),
3099 None,
3100 Some(&first.account_id),
3101 None,
3102 );
3103 let mut replay = IndexMap::new();
3104
3105 let mut flips = IndexMap::new();
3107 reports
3108 .iter()
3109 .take_while(|report| {
3110 report.instrument_id == first.instrument_id
3111 && report.account_id == first.account_id
3112 && position_fill_report_matches(
3113 &cache,
3114 report,
3115 &positions,
3116 |id| {
3117 if let Some(flip) = flips.get(&id) {
3118 return Ok(*flip);
3119 }
3120
3121 let flip = cache.hedging_flip_position_ids(id)?;
3122 flips.insert(id, flip);
3123 Ok(flip)
3124 },
3125 Some(&mut replay),
3126 )
3127 })
3128 .count()
3129 }
3130
3131 #[must_use]
3137 pub fn reconcile_position_reports(
3138 &mut self,
3139 check: &PositionReportCheck,
3140 reports: Vec<PositionStatusReport>,
3141 queried_clients: &IndexSet<ClientId>,
3142 failed_clients: &IndexSet<ClientId>,
3143 ) -> Vec<OrderEventAny> {
3144 log::debug!("Checking position consistency between cached-state and venues");
3145
3146 let venue_positions = self.group_position_reports(reports);
3147 let mut events = Vec::new();
3148
3149 for (key, coverage) in &check.client_coverage {
3150 let prepared_revision = check
3151 .activity_revisions
3152 .get(key)
3153 .copied()
3154 .unwrap_or_default();
3155
3156 if self.position_activity_revision(key) > prepared_revision {
3157 log::debug!(
3158 "Deferring position reconciliation for {}/{}: local activity recorded during report request",
3159 key.0,
3160 key.1,
3161 );
3162 continue;
3163 }
3164
3165 let venue_reports = venue_positions
3166 .get(key)
3167 .map(Vec::as_slice)
3168 .unwrap_or_default();
3169
3170 if venue_reports.is_empty() {
3171 match coverage {
3172 ReportClientCoverage::Resolved(responsible_clients)
3173 if responsible_clients.is_empty() =>
3174 {
3175 log::warn!(
3176 "Skipping position reconciliation for {}/{}: responsible execution client coverage is unresolved",
3177 key.0,
3178 key.1,
3179 );
3180 continue;
3181 }
3182 ReportClientCoverage::Resolved(responsible_clients)
3183 if !responsible_clients.is_subset(queried_clients) =>
3184 {
3185 log::warn!(
3186 "Skipping position reconciliation for {}/{}: responsible execution clients were not all queried",
3187 key.0,
3188 key.1,
3189 );
3190 continue;
3191 }
3192 ReportClientCoverage::Resolved(responsible_clients)
3193 if !responsible_clients.is_disjoint(failed_clients) =>
3194 {
3195 let failed_responsible_clients = responsible_clients
3196 .intersection(failed_clients)
3197 .copied()
3198 .collect::<IndexSet<_>>();
3199 log::warn!(
3200 "Skipping position reconciliation for {}/{}: failed to query responsible execution clients: {failed_responsible_clients:?}",
3201 key.0,
3202 key.1,
3203 );
3204 continue;
3205 }
3206 ReportClientCoverage::Resolved(_) => {}
3207 ReportClientCoverage::Unavailable(responsible_clients) => {
3208 log::debug!(
3209 "Skipping position reconciliation for {}/{}: complete bulk position coverage is unavailable from responsible execution clients: {responsible_clients:?}",
3210 key.0,
3211 key.1,
3212 );
3213 continue;
3214 }
3215 ReportClientCoverage::Unresolved => {
3216 log::warn!(
3217 "Skipping position reconciliation for {}/{}: responsible execution client coverage is unresolved",
3218 key.0,
3219 key.1,
3220 );
3221 continue;
3222 }
3223 }
3224 }
3225
3226 if let Some(discrepancy_events) = self.check_position_discrepancy(*key, venue_reports) {
3227 events.extend(discrepancy_events);
3228 }
3229 }
3230
3231 let current_position_keys = self.open_position_keys_for_reconciliation();
3232
3233 for (key, venue_reports) in &venue_positions {
3234 if check.client_coverage.contains_key(key)
3235 || venue_reports
3236 .iter()
3237 .all(|report| report.signed_decimal_qty == Decimal::ZERO)
3238 {
3239 continue;
3240 }
3241
3242 if current_position_keys.contains(key) {
3243 log::debug!(
3244 "Deferring position reconciliation for {}/{}: position opened after client coverage was recorded",
3245 key.0,
3246 key.1,
3247 );
3248 continue;
3249 }
3250
3251 if let Some(discrepancy_events) = self.check_position_discrepancy(*key, venue_reports) {
3252 events.extend(discrepancy_events);
3253 }
3254 }
3255
3256 events
3257 }
3258
3259 fn group_position_reports(
3260 &self,
3261 reports: impl IntoIterator<Item = PositionStatusReport>,
3262 ) -> IndexMap<InstrumentAccountKey, Vec<PositionStatusReport>> {
3263 let mut venue_positions: IndexMap<InstrumentAccountKey, Vec<PositionStatusReport>> =
3264 IndexMap::new();
3265
3266 for report in reports {
3267 if !self.should_reconcile_instrument(&report.instrument_id) {
3268 continue;
3269 }
3270
3271 venue_positions
3272 .entry((report.instrument_id, report.account_id))
3273 .or_default()
3274 .push(report);
3275 }
3276
3277 venue_positions
3278 .into_iter()
3279 .map(|(key, reports)| (key, distinct_position_reports(reports)))
3280 .collect()
3281 }
3282
3283 #[must_use]
3285 pub fn get_external_order_claim(&self, instrument_id: &InstrumentId) -> Option<StrategyId> {
3286 self.cache.borrow().external_order_claim(instrument_id)
3287 }
3288
3289 pub fn claim_external_orders(
3295 &mut self,
3296 instrument_id: InstrumentId,
3297 strategy_id: StrategyId,
3298 ) -> anyhow::Result<()> {
3299 self.cache
3300 .borrow_mut()
3301 .register_external_order_claims(strategy_id, &[instrument_id])
3302 }
3303
3304 pub fn observe_order_event(&mut self, event: &OrderEventAny) {
3314 match event {
3315 OrderEventAny::Filled(fill) => {
3316 self.record_position_activity(fill.instrument_id, fill.account_id);
3317 }
3318 OrderEventAny::ModifyDenied(event) => {
3319 self.clear_command_tracking(event.client_order_id, event.causation_id);
3320 }
3321 OrderEventAny::CancelDenied(event) => {
3322 self.clear_command_tracking(event.client_order_id, event.causation_id);
3323 }
3324 OrderEventAny::ModifyRejected(event) if event.causation_id.is_some() => {
3325 self.clear_command_tracking(event.client_order_id, event.causation_id);
3326 }
3327 OrderEventAny::CancelRejected(event) if event.causation_id.is_some() => {
3328 self.clear_command_tracking(event.client_order_id, event.causation_id);
3329 }
3330 OrderEventAny::Updated(event) if event.causation_id.is_some() => {
3331 self.clear_command_tracking(event.client_order_id, event.causation_id);
3332 }
3333 OrderEventAny::Accepted(_)
3334 | OrderEventAny::Rejected(_)
3335 | OrderEventAny::Canceled(_)
3336 | OrderEventAny::Expired(_)
3337 | OrderEventAny::Denied(_)
3338 | OrderEventAny::Updated(_)
3339 | OrderEventAny::ModifyRejected(_)
3340 | OrderEventAny::CancelRejected(_) => {
3341 self.clear_recon_tracking(&event.client_order_id(), true);
3342 }
3343 _ => {}
3344 }
3345
3346 self.record_local_activity(event.client_order_id());
3347 }
3348
3349 fn clear_command_tracking(
3350 &mut self,
3351 client_order_id: ClientOrderId,
3352 causation_id: Option<UUID4>,
3353 ) {
3354 let Some(command_id) = causation_id else {
3355 return;
3356 };
3357
3358 let Some(check) = self.order_inflight_checks.get_mut(&client_order_id) else {
3359 return;
3360 };
3361
3362 let Some(index) = check.command_ids.iter().position(|id| *id == command_id) else {
3363 return;
3364 };
3365
3366 check.command_ids.remove(index);
3367 if check.command_ids.is_empty() {
3368 self.clear_recon_tracking(&client_order_id, true);
3369 }
3370 }
3371
3372 pub fn observe_execution_report(&mut self, report: &ExecutionReport) {
3385 match report {
3386 ExecutionReport::Order(order_report) => {
3387 self.observe_order_report(order_report);
3388 }
3389 ExecutionReport::Fill(fill_report) => {
3390 let client_order_id = fill_report.client_order_id.or_else(|| {
3391 self.cache
3392 .borrow()
3393 .client_order_id(&fill_report.venue_order_id)
3394 .copied()
3395 });
3396
3397 if let Some(coid) = client_order_id {
3398 self.record_local_activity(coid);
3399 }
3400
3401 self.record_position_activity(fill_report.instrument_id, fill_report.account_id);
3402 }
3403 ExecutionReport::OrderWithFills(order_report, fills) => {
3404 self.observe_order_report(order_report);
3405
3406 for fill_report in fills {
3407 self.record_position_activity(
3408 fill_report.instrument_id,
3409 fill_report.account_id,
3410 );
3411 }
3412 }
3413 ExecutionReport::Position(position_report) => {
3414 self.record_position_activity(
3415 position_report.instrument_id,
3416 position_report.account_id,
3417 );
3418 }
3419 ExecutionReport::MassStatus(_) => {
3420 }
3422 }
3423 }
3424
3425 fn confirm_submitted_report(&mut self, report: &OrderStatusReport) -> bool {
3426 if report.order_status == OrderStatus::Submitted
3427 && let Some(client_order_id) = report.client_order_id
3428 && self.submission_retention_enabled(client_order_id, None)
3429 && let Some(order) = self.get_order(client_order_id)
3430 && self
3431 .submissions
3432 .get(&client_order_id)
3433 .is_none_or(|submission| {
3434 submission.trader_id == order.trader_id()
3435 && submission.strategy_id == order.strategy_id()
3436 && submission.instrument_id == order.instrument_id()
3437 })
3438 && report.instrument_id == order.instrument_id()
3439 && order.account_id() == Some(report.account_id)
3440 && order
3441 .venue_order_id()
3442 .is_none_or(|id| id == report.venue_order_id)
3443 && self
3444 .cache
3445 .borrow()
3446 .client_order_id(&report.venue_order_id)
3447 .is_none_or(|id| *id == client_order_id)
3448 {
3449 if Self::submission_is_unacknowledged(&order) {
3450 let client_id = self.cache.borrow().client_id(&client_order_id).copied();
3451 self.track_submission(order.init_event(), client_id);
3452 }
3453
3454 if let Some(submission) = self.submissions.get_mut(&client_order_id) {
3455 submission.venue_confirmed = true;
3456 }
3457
3458 self.clear_recon_tracking(&client_order_id, false);
3459 self.record_local_activity(client_order_id);
3460 return true;
3461 }
3462
3463 false
3464 }
3465
3466 fn observe_order_report(&mut self, report: &OrderStatusReport) {
3467 let Some(client_order_id) = report.client_order_id else {
3468 return;
3469 };
3470
3471 if self.confirm_submitted_report(report) {
3472 return;
3473 }
3474
3475 let accepted_during_pending_command = report.order_status == OrderStatus::Accepted
3476 && self.get_order(client_order_id).is_some_and(|order| {
3477 matches!(
3478 order.status(),
3479 OrderStatus::PendingUpdate | OrderStatus::PendingCancel
3480 )
3481 });
3482
3483 if !matches!(
3484 report.order_status,
3485 OrderStatus::PendingUpdate | OrderStatus::PendingCancel
3486 ) && !accepted_during_pending_command
3487 {
3488 self.clear_recon_tracking(&client_order_id, report.order_status.is_closed());
3489 }
3490
3491 self.record_local_activity(client_order_id);
3495 }
3496
3497 pub fn purge_closed_orders(&mut self) {
3499 let Some(buffer_mins) = self.config.purge_closed_orders_buffer_mins else {
3500 return;
3501 };
3502
3503 let ts_now = self.timestamp_ns();
3504 let buffer_secs = mins_to_secs(u64::from(buffer_mins));
3505
3506 if let Err(e) = self.cache.borrow_mut().purge_closed_orders(
3507 ts_now,
3508 buffer_secs,
3509 self.config.purge_from_database,
3510 ) {
3511 log::error!("Failed to purge cached state: {e}");
3512 }
3513 }
3514
3515 pub fn purge_closed_positions(&mut self) {
3517 let Some(buffer_mins) = self.config.purge_closed_positions_buffer_mins else {
3518 return;
3519 };
3520
3521 let ts_now = self.clock.borrow().timestamp_ns();
3522 let buffer_secs = mins_to_secs(u64::from(buffer_mins));
3523
3524 if let Err(e) = self.cache.borrow_mut().purge_closed_positions(
3525 ts_now,
3526 buffer_secs,
3527 self.config.purge_from_database,
3528 ) {
3529 log::error!("Failed to purge cached state: {e}");
3530 }
3531 }
3532
3533 pub fn purge_account_events(&mut self) {
3535 let Some(lookback_mins) = self.config.purge_account_events_lookback_mins else {
3536 return;
3537 };
3538
3539 let ts_now = self.clock.borrow().timestamp_ns();
3540 let lookback_secs = mins_to_secs(u64::from(lookback_mins));
3541
3542 if let Err(e) = self.cache.borrow_mut().purge_account_events(
3543 ts_now,
3544 lookback_secs,
3545 self.config.purge_from_database,
3546 ) {
3547 log::error!("Failed to purge cached state: {e}");
3548 }
3549 }
3550
3551 fn get_order(&self, client_order_id: ClientOrderId) -> Option<OrderAny> {
3552 self.cache().order(&client_order_id).map(|o| o.clone())
3553 }
3554
3555 fn get_order_by_venue_order_id(&self, venue_order_id: VenueOrderId) -> Option<OrderAny> {
3556 let cache = self.cache();
3557 cache
3558 .client_order_id(&venue_order_id)
3559 .and_then(|client_order_id| cache.order(client_order_id).map(|o| o.clone()))
3560 }
3561
3562 fn get_instrument(&self, instrument_id: &InstrumentId) -> Option<InstrumentAny> {
3563 self.cache().instrument(instrument_id).cloned()
3564 }
3565
3566 fn should_skip_order_report(&self, report: &OrderStatusReport) -> bool {
3567 let client_order_id = report.client_order_id.or_else(|| {
3568 self.cache
3569 .borrow()
3570 .client_order_id(&report.venue_order_id)
3571 .copied()
3572 });
3573
3574 if let Some(client_order_id) = client_order_id
3575 && self
3576 .config
3577 .filtered_client_order_ids
3578 .contains(&client_order_id)
3579 {
3580 log::debug!(
3581 "Skipping order report {client_order_id}: in filtered_client_order_ids list"
3582 );
3583 return true;
3584 }
3585
3586 if !self.should_reconcile_instrument(&report.instrument_id) {
3587 log::debug!(
3588 "Skipping order report for {}: not in reconciliation_instrument_ids",
3589 report.instrument_id
3590 );
3591 return true;
3592 }
3593
3594 false
3595 }
3596
3597 fn should_reconcile_instrument(&self, instrument_id: &InstrumentId) -> bool {
3599 self.config.reconciliation_instrument_ids.is_empty()
3600 || self
3601 .config
3602 .reconciliation_instrument_ids
3603 .contains(instrument_id)
3604 }
3605
3606 fn prepare_missing_order_query(&mut self, client_order_id: ClientOrderId) -> Option<OrderAny> {
3607 let order = self.get_order(client_order_id)?;
3608
3609 if self.submission_is_retained(client_order_id) {
3610 return None;
3611 }
3612
3613 if order.status().is_closed() {
3617 log::debug!(
3618 "Skipping missing-order resolution for {client_order_id}: already {}",
3619 order.status()
3620 );
3621 self.clear_recon_tracking(&client_order_id, true);
3622 return None;
3623 }
3624
3625 if self.order_activity.within(
3629 &client_order_id,
3630 Duration::from(self.config.open_check_threshold_ns),
3631 ) {
3632 return None;
3633 }
3634
3635 if order.is_inflight() && Self::submission_is_unacknowledged(&order) {
3636 let client_id = self.cache.borrow().client_id(&client_order_id).copied();
3637 self.track_submission(order.init_event(), client_id);
3638 }
3639
3640 let retries = self.order_recon_retries.entry(client_order_id).or_insert(0);
3641 *retries = retries.saturating_add(1);
3642
3643 if *retries < self.config.open_check_missing_retries {
3644 log::debug!(
3645 "Order {} not found at venue, retry {}/{}",
3646 client_order_id,
3647 retries,
3648 self.config.open_check_missing_retries
3649 );
3650 return None;
3651 }
3652
3653 Some(order)
3654 }
3655
3656 fn resolve_missing_order(&mut self, client_order_id: ClientOrderId) -> Vec<OrderEventAny> {
3657 let mut events = Vec::new();
3658
3659 let Some(order) = self.get_order(client_order_id) else {
3660 return events;
3661 };
3662
3663 if order.status().is_closed() {
3664 log::debug!(
3665 "Skipping missing-order resolution for {client_order_id}: already {}",
3666 order.status()
3667 );
3668 self.clear_recon_tracking(&client_order_id, true);
3669 return events;
3670 }
3671
3672 if self.order_activity.within(
3673 &client_order_id,
3674 Duration::from(self.config.open_check_threshold_ns),
3675 ) {
3676 log::debug!(
3677 "Deferring missing-order resolution for {client_order_id}: recent local activity"
3678 );
3679 return events;
3680 }
3681
3682 let retries = self.recon_check_retry_count(&client_order_id);
3683 let ts_now = self.clock.borrow().timestamp_ns();
3684
3685 let exhausted_retries = retries.max(self.config.open_check_missing_retries);
3688
3689 if self.submission_recovery_pending(client_order_id)
3690 && !self.order_inflight_checks.contains_key(&client_order_id)
3691 {
3692 self.exhaust_submission(
3693 client_order_id,
3694 SubmissionRecoverySource::MissingOrder,
3695 exhausted_retries,
3696 );
3697 return events;
3698 }
3699
3700 match order.status() {
3701 OrderStatus::Accepted | OrderStatus::Submitted => {
3702 if order.status() == OrderStatus::Submitted
3703 && self.exhaust_submission(
3704 client_order_id,
3705 SubmissionRecoverySource::MissingOrder,
3706 exhausted_retries,
3707 )
3708 {
3709 return events;
3710 }
3711
3712 log::warn!(
3713 "Order {client_order_id} not found at venue after {retries} retries and a targeted query, marking as REJECTED"
3714 );
3715
3716 if let Some(rejected) =
3717 create_reconciliation_rejected(&order, Some("NOT_FOUND_AT_VENUE"), ts_now)
3718 {
3719 events.push(rejected);
3720 }
3721 }
3722 OrderStatus::PartiallyFilled => {
3723 log::warn!(
3724 "Order {client_order_id} not found at venue after {retries} retries and a targeted query, marking as CANCELED"
3725 );
3726 events.push(create_reconciliation_canceled(&order, ts_now));
3727 }
3728 OrderStatus::PendingUpdate | OrderStatus::PendingCancel => {
3729 log::debug!(
3730 "Deferring resolution for {client_order_id}: still inflight as {}",
3731 order.status()
3732 );
3733
3734 if self.submission_recovery_pending(client_order_id) {
3735 return events;
3736 }
3737
3738 self.order_recon_retries.shift_remove(&client_order_id);
3747 if let Some(check) = self.order_inflight_checks.get_mut(&client_order_id) {
3748 check.retry_count = 0;
3749 check.last_query_at = Some(dst::time::Instant::now());
3750 }
3751
3752 self.order_query_recency.mark(client_order_id);
3753 return events;
3754 }
3755 status => {
3756 log::warn!(
3757 "Skipping missing-order resolution for {client_order_id}: unexpected status {status}"
3758 );
3759 }
3760 }
3761
3762 self.clear_recon_tracking(&client_order_id, true);
3763 events
3764 }
3765
3766 fn position_quantity_comparison(
3768 &self,
3769 key: InstrumentAccountKey,
3770 venue_reports: &[PositionStatusReport],
3771 ) -> PositionQuantityComparison {
3772 let (instrument_id, account_id) = key;
3773
3774 let cached_positions = {
3775 let cache = self.cache.borrow();
3776 cache
3777 .positions_open(None, Some(&instrument_id), None, Some(&account_id), None)
3778 .into_iter()
3779 .map(|position| (*position).clone())
3780 .collect::<Vec<_>>()
3781 };
3782
3783 let (cached_signed_qty, cached_long_qty, cached_short_qty) =
3784 position_qty_aggregates(cached_positions.iter().map(Position::signed_decimal_qty));
3785 let (venue_signed_qty, venue_long_qty, venue_short_qty) =
3786 position_qty_aggregates(venue_reports.iter().map(|report| report.signed_decimal_qty));
3787 let nonflat_count = venue_reports
3788 .iter()
3789 .filter(|report| report.signed_decimal_qty != Decimal::ZERO)
3790 .count();
3791 let venue_report = venue_reports
3792 .iter()
3793 .find(|report| report.signed_decimal_qty != Decimal::ZERO)
3794 .or_else(|| venue_reports.last())
3795 .cloned();
3796 let venue_has_side_reports = venue_reports.iter().any(PositionStatusReport::is_long)
3797 && venue_reports.iter().any(PositionStatusReport::is_short);
3798
3799 PositionQuantityComparison {
3800 cached_positions,
3801 cached_signed_qty,
3802 cached_long_qty,
3803 cached_short_qty,
3804 venue_signed_qty,
3805 venue_long_qty,
3806 venue_short_qty,
3807 nonflat_count,
3808 venue_report,
3809 venue_has_side_reports,
3810 }
3811 }
3812
3813 fn check_position_discrepancy(
3814 &mut self,
3815 key: InstrumentAccountKey,
3816 venue_reports: &[PositionStatusReport],
3817 ) -> Option<Vec<OrderEventAny>> {
3818 let (instrument_id, account_id) = key;
3819 let comparison = self.position_quantity_comparison(key, venue_reports);
3820 let tolerance = self.position_reconciliation_tolerance(account_id);
3821 let quantities_match = comparison.quantities_match(tolerance);
3822 let report_shape = comparison.report_shape();
3823 let PositionQuantityComparison {
3824 cached_positions,
3825 cached_signed_qty,
3826 cached_long_qty,
3827 cached_short_qty,
3828 venue_signed_qty,
3829 venue_long_qty,
3830 venue_short_qty,
3831 venue_report,
3832 ..
3833 } = comparison;
3834
3835 if quantities_match {
3836 self.clear_position_reconciliation(&key);
3837 return None;
3838 }
3839
3840 if !self.config.generate_missing_orders {
3841 log::debug!(
3842 "Discrepancy for {instrument_id} position when `generate_missing_orders` disabled, skipping"
3843 );
3844 return None;
3845 }
3846
3847 let ts_now = self.clock.borrow().timestamp_ns();
3848
3849 if self.position_activity_is_recent(&key) {
3851 log::debug!(
3852 "Skipping position reconciliation for {instrument_id}: recent activity within threshold"
3853 );
3854 return None;
3855 }
3856
3857 let retries = self.position_reconciliation_retries(&key, report_shape);
3858
3859 if retries >= self.config.position_check_retries {
3860 return None;
3861 }
3862
3863 if report_shape == PositionReportShape::MultiLeg {
3864 let new_retries = retries + 1;
3865 self.set_position_reconciliation_retries(key, report_shape, new_retries);
3866 log::warn!(
3867 "Deferring position reconciliation for {instrument_id}/{account_id}: venue reports have ambiguous side aggregates (cached net={cached_signed_qty}, long={cached_long_qty}, short={cached_short_qty}; venue net={venue_signed_qty}, long={venue_long_qty}, short={venue_short_qty})"
3868 );
3869
3870 if new_retries >= self.config.position_check_retries {
3871 log::error!(
3872 "Position discrepancy for {instrument_id}/{account_id} unresolved after {} attempts; no further reconciliation attempts will be made for the current report shape",
3873 self.config.position_check_retries,
3874 );
3875 }
3876
3877 return None;
3878 }
3879
3880 log::warn!(
3881 "Position discrepancy detected for {instrument_id}: cached_signed_qty={cached_signed_qty}, venue_signed_qty={venue_signed_qty}"
3882 );
3883
3884 let Some(instrument) = self.get_instrument(&instrument_id) else {
3885 log::debug!("Cannot reconcile position for {instrument_id}: instrument not in cache");
3886 let new_retries = retries + 1;
3887 self.set_position_reconciliation_retries(key, report_shape, new_retries);
3888 if new_retries >= self.config.position_check_retries {
3889 log::error!(
3890 "Position discrepancy for {instrument_id} unresolved after {} attempts \
3891 (cached_qty={cached_signed_qty}, venue_qty={venue_signed_qty}); \
3892 no further reconciliation attempts will be made for the current report shape",
3893 self.config.position_check_retries,
3894 );
3895 }
3896
3897 return None;
3898 };
3899
3900 let cached_avg_px = position_avg_px(&cached_positions);
3901 let venue_avg_px = venue_report.as_ref().and_then(|r| r.avg_px_open);
3902 let venue_position_id = venue_report
3903 .as_ref()
3904 .and_then(|report| report.venue_position_id);
3905 let venue_ts_last = venue_report.as_ref().map_or(ts_now, |r| r.ts_last);
3906
3907 let crosses_zero = (cached_signed_qty > Decimal::ZERO && venue_signed_qty < Decimal::ZERO)
3908 || (cached_signed_qty < Decimal::ZERO && venue_signed_qty > Decimal::ZERO);
3909
3910 let result = if crosses_zero {
3911 let position_ids = match venue_position_id {
3912 Some(open_position_id) => match cached_positions.as_slice() {
3913 [position] => Some((Some(position.id), Some(open_position_id))),
3914 _ => {
3915 log::warn!(
3916 "Deferring hedge cross-zero reconciliation for {instrument_id}/{account_id}: cached and venue position identities are ambiguous"
3917 );
3918 None
3919 }
3920 },
3921 None => Some((None, None)),
3922 };
3923
3924 position_ids.and_then(|(close_position_id, open_position_id)| {
3925 self.reconcile_cross_zero_position(
3926 &instrument,
3927 account_id,
3928 cached_signed_qty,
3929 cached_avg_px,
3930 venue_signed_qty,
3931 venue_avg_px,
3932 close_position_id,
3933 open_position_id,
3934 ts_now,
3935 venue_ts_last,
3936 )
3937 })
3938 } else {
3939 let qty_diff = venue_signed_qty - cached_signed_qty;
3940
3941 let order_side = if qty_diff > Decimal::ZERO {
3942 OrderSide::Buy
3943 } else {
3944 OrderSide::Sell
3945 };
3946
3947 let reconciliation_px = calculate_reconciliation_price(
3948 cached_signed_qty,
3949 cached_avg_px,
3950 venue_signed_qty,
3951 venue_avg_px,
3952 venue_report
3953 .as_ref()
3954 .map(|report| report.avg_px_open_reconciliation)
3955 .unwrap_or_default(),
3956 venue_report
3957 .as_ref()
3958 .and_then(|report| report.avg_px_open_precision),
3959 );
3960
3961 reconciliation_px
3962 .or(venue_avg_px)
3963 .or(cached_avg_px)
3964 .and_then(|fill_px| {
3965 let quantity =
3966 Quantity::from_decimal_dp(qty_diff.abs(), instrument.size_precision())
3967 .ok()?;
3968 let order_report = create_position_reconciliation_report(
3969 &instrument,
3970 account_id,
3971 order_side,
3972 quantity,
3973 fill_px,
3974 venue_position_id,
3975 None,
3976 ts_now,
3977 venue_ts_last,
3978 );
3979
3980 log::info!(
3981 color = LogColor::Blue as u8;
3982 "Generating synthetic fill for position reconciliation {instrument_id}: side={order_side:?}, qty={}, px={fill_px}", qty_diff.abs(),
3983 );
3984
3985 let (events, _) = self.handle_external_order(
3986 &order_report,
3987 account_id,
3988 &instrument,
3989 &[],
3990 true,
3991 None,
3992 None,
3993 );
3994 Some(events)
3995 })
3996 };
3997
3998 if result.as_ref().is_none_or(Vec::is_empty) {
4000 let new_retries = retries + 1;
4001 self.set_position_reconciliation_retries(key, report_shape, new_retries);
4002 if new_retries >= self.config.position_check_retries {
4003 log::error!(
4004 "Position discrepancy for {} unresolved after {} attempts \
4005 (cached_qty={}, venue_qty={}); \
4006 no further reconciliation attempts will be made for the current report shape",
4007 instrument_id,
4008 self.config.position_check_retries,
4009 cached_signed_qty,
4010 venue_signed_qty,
4011 );
4012 }
4013 } else {
4014 self.clear_position_reconciliation(&key);
4015 }
4016
4017 result
4018 }
4019
4020 #[expect(clippy::too_many_arguments)]
4023 fn reconcile_cross_zero_position(
4024 &self,
4025 instrument: &InstrumentAny,
4026 account_id: AccountId,
4027 cached_signed_qty: Decimal,
4028 cached_avg_px: Option<Decimal>,
4029 venue_signed_qty: Decimal,
4030 venue_avg_px: Option<Decimal>,
4031 close_position_id: Option<PositionId>,
4032 open_position_id: Option<PositionId>,
4033 ts_now: UnixNanos,
4034 venue_ts_last: UnixNanos,
4035 ) -> Option<Vec<OrderEventAny>> {
4036 let instrument_id = instrument.id();
4037
4038 log::info!(
4039 color = LogColor::Blue as u8;
4040 "Position crosses zero for {instrument_id}: cached={cached_signed_qty}, venue={venue_signed_qty}. Splitting into two fills",
4041 );
4042
4043 let close_qty = cached_signed_qty.abs();
4044
4045 let close_side = if cached_signed_qty < Decimal::ZERO {
4046 OrderSide::Buy } else {
4048 OrderSide::Sell };
4050
4051 let open_qty = venue_signed_qty.abs();
4052
4053 let open_side = if venue_signed_qty > Decimal::ZERO {
4054 OrderSide::Buy } else {
4056 OrderSide::Sell };
4058
4059 let Some(close_px) = cached_avg_px else {
4060 log::warn!("Cannot close position for {instrument_id}: no cached average price");
4061 return None;
4062 };
4063
4064 let open_report = match venue_avg_px {
4065 Some(open_px) => {
4066 let quantity =
4067 Quantity::from_decimal_dp(open_qty, instrument.size_precision()).ok()?;
4068 let report = create_position_reconciliation_report(
4069 instrument,
4070 account_id,
4071 open_side,
4072 quantity,
4073 open_px,
4074 open_position_id,
4075 Some("OPEN"),
4076 ts_now,
4077 venue_ts_last,
4078 );
4079 Some((report, open_px))
4080 }
4081 None => None,
4082 };
4083
4084 let quantity = Quantity::from_decimal_dp(close_qty, instrument.size_precision()).ok()?;
4085 let close_report = create_position_reconciliation_report(
4086 instrument,
4087 account_id,
4088 close_side,
4089 quantity,
4090 close_px,
4091 close_position_id,
4092 Some("CLOSE"),
4093 ts_now,
4094 venue_ts_last,
4095 );
4096
4097 log::info!(
4098 color = LogColor::Blue as u8;
4099 "Generating close fill for cross-zero {instrument_id}: side={close_side:?}, qty={close_qty}, px={close_px}",
4100 );
4101
4102 let (close_events, _) = self.handle_external_order(
4103 &close_report,
4104 account_id,
4105 instrument,
4106 &[],
4107 true,
4108 None,
4109 None,
4110 );
4111 let mut all_events = close_events;
4112
4113 if let Some((open_report, open_px)) = open_report {
4114 log::info!(
4115 color = LogColor::Blue as u8;
4116 "Generating open fill for cross-zero {instrument_id}: side={open_side:?}, qty={open_qty}, px={open_px}",
4117 );
4118
4119 let (open_events, _) = self.handle_external_order(
4120 &open_report,
4121 account_id,
4122 instrument,
4123 &[],
4124 true,
4125 None,
4126 None,
4127 );
4128 all_events.extend(open_events);
4129 } else {
4130 log::warn!("Cannot open new position for {instrument_id}: no venue average price");
4131 }
4132
4133 Some(all_events)
4134 }
4135
4136 fn reconcile_position_report(
4137 &self,
4138 report: &PositionStatusReport,
4139 account_id: AccountId,
4140 instruments_with_unattributed_fills: &IndexSet<InstrumentId>,
4141 ) -> Option<Vec<OrderEventAny>> {
4142 match report.venue_position_id {
4143 Some(venue_position_id) => self.reconcile_position_report_hedging(
4144 report,
4145 venue_position_id,
4146 account_id,
4147 instruments_with_unattributed_fills,
4148 ),
4149 None => self.reconcile_position_report_netting(report, account_id),
4150 }
4151 }
4152
4153 fn reconcile_position_report_hedging(
4154 &self,
4155 report: &PositionStatusReport,
4156 venue_position_id: PositionId,
4157 account_id: AccountId,
4158 instruments_with_unattributed_fills: &IndexSet<InstrumentId>,
4159 ) -> Option<Vec<OrderEventAny>> {
4160 if instruments_with_unattributed_fills.contains(&report.instrument_id) {
4163 log::debug!(
4164 "Skipping hedge position {venue_position_id} reconciliation: unattributed fills in batch"
4165 );
4166 return None;
4167 }
4168
4169 log::debug!(
4170 "Reconciling HEDGE position for {}, venue_position_id={}",
4171 report.instrument_id,
4172 venue_position_id
4173 );
4174
4175 let position = {
4176 let cache = self.cache.borrow();
4177 cache.position_owned(&venue_position_id)
4178 };
4179
4180 match position {
4181 Some(position) => {
4182 let cached_signed_qty = position.signed_decimal_qty();
4183 let venue_signed_qty = report.signed_decimal_qty;
4184
4185 if cached_signed_qty == venue_signed_qty {
4186 log::debug!(
4187 "Hedge position {venue_position_id} matches venue: qty={cached_signed_qty}"
4188 );
4189 return None;
4190 }
4191
4192 if !self.config.generate_missing_orders {
4193 log::error!(
4194 "Cannot reconcile {} {}: position net qty {} != reported net qty {} \
4195 and `generate_missing_orders` is disabled",
4196 report.instrument_id,
4197 venue_position_id,
4198 cached_signed_qty,
4199 venue_signed_qty
4200 );
4201 return None;
4202 }
4203
4204 self.reconcile_hedge_position_discrepancy(
4205 report,
4206 venue_position_id,
4207 account_id,
4208 &position,
4209 cached_signed_qty,
4210 )
4211 }
4212 None => {
4213 if report.signed_decimal_qty == Decimal::ZERO {
4214 return None;
4215 }
4216
4217 if !self.config.generate_missing_orders {
4218 log::error!(
4219 "Cannot reconcile position: {venue_position_id} not found and `generate_missing_orders` is disabled"
4220 );
4221 return None;
4222 }
4223
4224 self.reconcile_missing_hedge_position(report, venue_position_id, account_id)
4225 }
4226 }
4227 }
4228
4229 fn reconcile_hedge_position_discrepancy(
4230 &self,
4231 report: &PositionStatusReport,
4232 venue_position_id: PositionId,
4233 account_id: AccountId,
4234 position: &Position,
4235 cached_signed_qty: Decimal,
4236 ) -> Option<Vec<OrderEventAny>> {
4237 let instrument = self.get_instrument(&report.instrument_id)?;
4238 let venue_signed_qty = report.signed_decimal_qty;
4239
4240 let diff = (cached_signed_qty - venue_signed_qty).abs();
4241 let diff_qty = Quantity::from_decimal_dp(diff, instrument.size_precision()).ok()?;
4242
4243 if diff_qty.is_zero() {
4244 log::debug!(
4245 "Difference quantity rounds to zero for {}, skipping",
4246 instrument.id()
4247 );
4248 return None;
4249 }
4250
4251 log::warn!(
4252 "Hedge position discrepancy for {} {}: cached={}, venue={}, generating reconciliation order",
4253 report.instrument_id,
4254 venue_position_id,
4255 cached_signed_qty,
4256 venue_signed_qty
4257 );
4258
4259 let current_avg_px = if position.avg_px_open > Decimal::ZERO {
4260 Some(position.avg_px_open)
4261 } else {
4262 None
4263 };
4264
4265 self.create_position_reconciliation_order(
4266 report,
4267 account_id,
4268 &instrument,
4269 cached_signed_qty,
4270 diff_qty,
4271 current_avg_px,
4272 )
4273 }
4274
4275 fn reconcile_missing_hedge_position(
4276 &self,
4277 report: &PositionStatusReport,
4278 venue_position_id: PositionId,
4279 account_id: AccountId,
4280 ) -> Option<Vec<OrderEventAny>> {
4281 let instrument = self.get_instrument(&report.instrument_id)?;
4282 let venue_signed_qty = report.signed_decimal_qty;
4283
4284 let qty = venue_signed_qty.abs();
4285 let diff_qty = Quantity::from_decimal_dp(qty, instrument.size_precision()).ok()?;
4286
4287 if diff_qty.is_zero() {
4288 return None;
4289 }
4290
4291 log::warn!(
4292 "Missing hedge position for {} {}: venue reports {}, generating reconciliation order",
4293 report.instrument_id,
4294 venue_position_id,
4295 venue_signed_qty
4296 );
4297
4298 self.create_position_reconciliation_order(
4299 report,
4300 account_id,
4301 &instrument,
4302 Decimal::ZERO,
4303 diff_qty,
4304 None,
4305 )
4306 }
4307
4308 fn reconcile_position_report_netting(
4309 &self,
4310 report: &PositionStatusReport,
4311 account_id: AccountId,
4312 ) -> Option<Vec<OrderEventAny>> {
4313 let instrument_id = report.instrument_id;
4314
4315 log::debug!("Reconciling NET position for {instrument_id}");
4316
4317 let instrument = self.get_instrument(&instrument_id)?;
4318
4319 let (cached_signed_qty, cached_avg_px) = {
4320 let cache = self.cache.borrow();
4321 let positions =
4322 cache.positions_open(None, Some(&instrument_id), None, Some(&account_id), None);
4323 let cached_signed_qty = positions
4324 .iter()
4325 .map(|position| position.signed_decimal_qty())
4326 .sum::<Decimal>();
4327 let cached_avg_px = position_avg_px(positions.iter().map(|position| &**position));
4328
4329 (cached_signed_qty, cached_avg_px)
4330 };
4331
4332 let venue_signed_qty = report.signed_decimal_qty;
4333
4334 log::debug!("venue_signed_qty={venue_signed_qty}, cached_signed_qty={cached_signed_qty}");
4335
4336 let diff = (cached_signed_qty - venue_signed_qty).abs();
4337 let tolerance = self.position_reconciliation_tolerance(account_id);
4338 if diff <= tolerance {
4339 log::debug!("Position quantities match for {instrument_id}, no reconciliation needed");
4340 return None;
4341 }
4342
4343 if !self.config.generate_missing_orders {
4344 log::debug!(
4345 "Discrepancy for {instrument_id} position when `generate_missing_orders` disabled, skipping"
4346 );
4347 return None;
4348 }
4349
4350 let diff_qty = Quantity::from_decimal_dp(diff, instrument.size_precision()).ok()?;
4351
4352 if diff_qty.is_zero() {
4353 log::debug!(
4354 "Difference quantity rounds to zero for {instrument_id}, skipping order generation"
4355 );
4356 return None;
4357 }
4358
4359 let crosses_zero = (cached_signed_qty > Decimal::ZERO && venue_signed_qty < Decimal::ZERO)
4360 || (cached_signed_qty < Decimal::ZERO && venue_signed_qty > Decimal::ZERO);
4361
4362 if crosses_zero {
4363 let ts_now = self.clock.borrow().timestamp_ns();
4364 return self.reconcile_cross_zero_position(
4365 &instrument,
4366 account_id,
4367 cached_signed_qty,
4368 cached_avg_px,
4369 venue_signed_qty,
4370 report.avg_px_open,
4371 None,
4372 None,
4373 ts_now,
4374 report.ts_last,
4375 );
4376 }
4377
4378 if cached_signed_qty == Decimal::ZERO {
4379 return self.create_position_from_report(report, account_id, &instrument);
4380 }
4381
4382 self.create_position_reconciliation_order(
4383 report,
4384 account_id,
4385 &instrument,
4386 cached_signed_qty,
4387 diff_qty,
4388 cached_avg_px,
4389 )
4390 }
4391
4392 fn create_position_from_report(
4397 &self,
4398 report: &PositionStatusReport,
4399 account_id: AccountId,
4400 instrument: &InstrumentAny,
4401 ) -> Option<Vec<OrderEventAny>> {
4402 let instrument_id = report.instrument_id;
4403 let venue_signed_qty = report.signed_decimal_qty;
4404
4405 if venue_signed_qty == Decimal::ZERO {
4406 return None;
4407 }
4408
4409 let order_side = if venue_signed_qty > Decimal::ZERO {
4410 OrderSide::Buy
4411 } else {
4412 OrderSide::Sell
4413 };
4414
4415 let qty_abs = venue_signed_qty.abs();
4416 let venue_avg_px = report.avg_px_open?;
4417
4418 let ts_now = self.clock.borrow().timestamp_ns();
4419 let order_qty = Quantity::from_decimal_dp(qty_abs, instrument.size_precision()).ok()?;
4420 let order_report = create_position_reconciliation_report(
4421 instrument,
4422 account_id,
4423 order_side,
4424 order_qty,
4425 venue_avg_px,
4426 report.venue_position_id,
4427 None,
4428 ts_now,
4429 report.ts_last,
4430 );
4431
4432 log::info!(
4433 color = LogColor::Blue as u8;
4434 "Creating position from venue report for {instrument_id}: side={order_side:?}, qty={qty_abs}, avg_px={venue_avg_px}",
4435 );
4436
4437 let (events, _) = self.handle_external_order(
4438 &order_report,
4439 account_id,
4440 instrument,
4441 &[],
4442 true,
4443 None,
4444 None,
4445 );
4446 Some(events)
4447 }
4448
4449 fn create_position_reconciliation_order(
4450 &self,
4451 report: &PositionStatusReport,
4452 account_id: AccountId,
4453 instrument: &InstrumentAny,
4454 cached_signed_qty: Decimal,
4455 diff_qty: Quantity,
4456 current_avg_px: Option<Decimal>,
4457 ) -> Option<Vec<OrderEventAny>> {
4458 let venue_signed_qty = report.signed_decimal_qty;
4459 let instrument_id = report.instrument_id;
4460
4461 let order_side = if venue_signed_qty > cached_signed_qty {
4462 OrderSide::Buy
4463 } else {
4464 OrderSide::Sell
4465 };
4466
4467 let reconciliation_px = calculate_reconciliation_price(
4468 cached_signed_qty,
4469 current_avg_px,
4470 venue_signed_qty,
4471 report.avg_px_open,
4472 report.avg_px_open_reconciliation,
4473 report.avg_px_open_precision,
4474 );
4475
4476 let fill_px = reconciliation_px
4477 .or(report.avg_px_open)
4478 .or(current_avg_px)?;
4479
4480 let ts_now = self.clock.borrow().timestamp_ns();
4481 let order_report = create_position_reconciliation_report(
4482 instrument,
4483 account_id,
4484 order_side,
4485 diff_qty,
4486 fill_px,
4487 report.venue_position_id,
4488 None,
4489 ts_now,
4490 report.ts_last,
4491 );
4492
4493 log::info!(
4494 color = LogColor::Blue as u8;
4495 "Generating reconciliation order for {instrument_id}: side={order_side:?}, qty={diff_qty}, px={fill_px}",
4496 );
4497
4498 let (events, _) = self.handle_external_order(
4499 &order_report,
4500 account_id,
4501 instrument,
4502 &[],
4503 true,
4504 None,
4505 None,
4506 );
4507 Some(events)
4508 }
4509
4510 fn reconcile_order_report(
4511 &self,
4512 order: &OrderAny,
4513 report: &OrderStatusReport,
4514 instrument: Option<&InstrumentAny>,
4515 commission_client: Option<&dyn ExecutionClient>,
4516 ) -> anyhow::Result<Vec<OrderEventAny>> {
4517 let requires_authoritative_fills =
4518 commission_client.is_some_and(ExecutionClient::requires_authoritative_fills);
4519 let has_missing_fills = order_report_has_missing_fills(
4520 report,
4521 order.filled_qty(),
4522 requires_authoritative_fills,
4523 );
4524
4525 if has_missing_fills
4526 && requires_authoritative_fills
4527 && order.status() == OrderStatus::Submitted
4528 {
4529 let ts_now = self.clock.borrow().timestamp_ns();
4530 let events = generate_reconciliation_order_pre_fill_events(order, report, ts_now);
4531 return Ok(events);
4532 }
4533
4534 anyhow::ensure!(
4535 !has_missing_fills,
4536 "order report for {} has unaccounted fills; waiting for fill reports",
4537 order.client_order_id(),
4538 );
4539 let ts_now = self.clock.borrow().timestamp_ns();
4540
4541 let mut events = Vec::new();
4542 let mut amended = None;
4543
4544 if order.status() == OrderStatus::PendingUpdate
4545 && matches!(
4546 report.order_status,
4547 OrderStatus::Accepted | OrderStatus::Triggered | OrderStatus::PartiallyFilled
4548 )
4549 && should_reconciliation_update(order, report)
4550 {
4551 events = generate_reconciliation_order_pre_fill_events(order, report, ts_now);
4552 let mut working = order.clone();
4553 for event in &events {
4554 working
4555 .apply(event.clone())
4556 .context("failed to project reconciled amendment")?;
4557 }
4558
4559 amended = Some(working);
4560 }
4561
4562 let order = amended.as_ref().unwrap_or(order);
4563 let commission = if matches!(
4564 report.order_status,
4565 OrderStatus::PartiallyFilled | OrderStatus::Filled
4566 ) && report.filled_qty > order.filled_qty()
4567 && let Some(instrument) = instrument
4568 {
4569 let fill_qty = report.filled_qty - order.filled_qty();
4570 let price_and_liquidity =
4571 incremental_inferred_fill_price_and_liquidity(order, report, instrument);
4572
4573 resolve_inferred_fill_commission(
4574 fill_qty,
4575 price_and_liquidity,
4576 instrument,
4577 commission_client,
4578 )?
4579 } else {
4580 None
4581 };
4582
4583 if matches!(
4584 report.order_status,
4585 OrderStatus::Canceled | OrderStatus::Expired
4586 ) && order.status() == OrderStatus::Filled
4587 && report.filled_qty == order.filled_qty()
4588 {
4589 return Ok(Vec::new());
4590 }
4591
4592 events.extend(reconcile_order_report_with_commission(
4593 order, report, instrument, ts_now, commission,
4594 ));
4595 Ok(events)
4596 }
4597
4598 #[expect(
4600 clippy::too_many_arguments,
4601 reason = "Snapshot and continuous reports share fill projection"
4602 )]
4603 fn reconcile_order_with_fills(
4604 &mut self,
4605 is_snapshot: bool,
4606 order: &OrderAny,
4607 report: &OrderStatusReport,
4608 fills: &[&FillReport],
4609 instrument: Option<&InstrumentAny>,
4610 fill_queue: &mut ReconciliationFillQueue,
4611 commission_client: Option<&dyn ExecutionClient>,
4612 ) -> Vec<OrderEventAny> {
4613 let requires_authoritative_fills =
4614 commission_client.is_some_and(ExecutionClient::requires_authoritative_fills);
4615 let current_report = preserve_order_amendment(order, report, requires_authoritative_fills);
4616 let report = current_report.as_ref();
4617 self.confirm_submitted_report(report);
4618 let mut events = Vec::new();
4619 let mut working = order.clone();
4620 let mut sorted_fills: Vec<&FillReport> = fills.to_vec();
4621 sorted_fills.sort_by_key(|f| f.ts_event);
4622
4623 let ts_now = self.clock.borrow().timestamp_ns();
4624 if matches!(
4625 report.order_status,
4626 OrderStatus::Canceled | OrderStatus::Expired
4627 ) && report.ts_triggered.is_some()
4628 && working.status() != OrderStatus::Triggered
4629 && TRIGGERABLE_ORDER_TYPES.contains(&working.order_type())
4630 {
4631 let triggered = create_reconciliation_triggered(&working, report, ts_now);
4632 if working.apply(triggered.clone()).is_ok() {
4633 events.push(triggered);
4634 }
4635 }
4636
4637 let requires_snapshot_projection = !sorted_fills.is_empty()
4638 || is_snapshot
4639 && (report.order_status == OrderStatus::Voided
4640 || report.filled_qty < working.filled_qty()
4641 || report.order_status == OrderStatus::Filled
4642 && report.quantity < working.quantity());
4643 if !requires_snapshot_projection {
4644 match self.reconcile_order_report(&working, report, instrument, commission_client) {
4645 Ok(order_events) => events.extend(order_events),
4646 Err(e) => log::error!(
4647 "Deferring order reconciliation for {}: {e}",
4648 order.client_order_id(),
4649 ),
4650 }
4651
4652 return events;
4653 }
4654
4655 for event in generate_reconciliation_order_pre_fill_events(&working, report, ts_now) {
4656 if let Err(e) = working.apply(event.clone()) {
4657 log::warn!(
4658 "Cannot project reconciliation event for {}: {e}",
4659 order.client_order_id()
4660 );
4661 return events;
4662 }
4663
4664 events.push(event);
4665 }
4666
4667 if let Some(inst) = instrument {
4668 for fill in sorted_fills {
4669 let Some((event, fill_key)) =
4670 self.create_order_fill(&working, fill, inst, &fill_queue.pending_fill_keys)
4671 else {
4672 continue;
4673 };
4674
4675 if let Err(e) = working.apply(OrderEventAny::Filled(event.clone())) {
4676 if self.applied_fill_key(&event) == Some(fill_key) {
4677 self.fills_processed.mark(fill_key);
4678 continue;
4679 }
4680
4681 log::warn!(
4682 "Cannot project reconciliation fill for {}: {e}",
4683 order.client_order_id()
4684 );
4685 return events;
4686 }
4687
4688 fill_queue.push(&mut events, event, fill_key);
4689 }
4690 }
4691
4692 if !is_snapshot {
4694 match self.reconcile_order_report(&working, report, instrument, commission_client) {
4695 Ok(order_events) => events.extend(order_events),
4696 Err(e) => log::warn!("Deferring order reconciliation: {e}"),
4697 }
4698
4699 return events;
4700 }
4701
4702 if order_report_has_missing_fills(
4703 report,
4704 working.filled_qty(),
4705 requires_authoritative_fills,
4706 ) {
4707 log::warn!(
4708 "Deferring terminal reconciliation for {}: fill reports are incomplete",
4709 order.client_order_id(),
4710 );
4711 return events;
4712 }
4713
4714 let commission = if report.filled_qty > working.filled_qty()
4715 && let Some(instrument) = instrument
4716 {
4717 let fill_qty = report.filled_qty - working.filled_qty();
4718
4719 let price_and_liquidity =
4720 incremental_inferred_fill_price_and_liquidity(&working, report, instrument);
4721
4722 match resolve_inferred_fill_commission(
4723 fill_qty,
4724 price_and_liquidity,
4725 instrument,
4726 commission_client,
4727 ) {
4728 Ok(commission) => commission,
4729 Err(e) => {
4730 log::error!(
4731 "Deferring inferred fill for {}: venue commission calculation failed: {e}",
4732 order.client_order_id(),
4733 );
4734 return events;
4735 }
4736 }
4737 } else {
4738 None
4739 };
4740
4741 for event in generate_reconciliation_order_snapshot_events_with_commission(
4742 &working, report, instrument, ts_now, commission,
4743 ) {
4744 if let Err(e) = working.apply(event.clone()) {
4745 log::warn!(
4746 "Cannot project reconciliation snapshot event for {}: {e}",
4747 order.client_order_id()
4748 );
4749 break;
4750 }
4751
4752 events.push(event);
4753 }
4754
4755 events
4756 }
4757
4758 #[expect(clippy::too_many_arguments)]
4759 fn handle_external_order(
4760 &self,
4761 report: &OrderStatusReport,
4762 account_id: AccountId,
4763 instrument: &InstrumentAny,
4764 fills: &[&FillReport],
4765 is_synthetic: bool,
4766 fill_queue: Option<&mut ReconciliationFillQueue>,
4767 commission_client: Option<&dyn ExecutionClient>,
4768 ) -> (Vec<OrderEventAny>, Option<ExternalOrderMetadata>) {
4769 let claimed_strategy = self
4770 .cache
4771 .borrow()
4772 .external_order_claim(&report.instrument_id);
4773 let (strategy_id, tags) = if let Some(claimed_strategy) = claimed_strategy {
4774 let order_id = report
4775 .client_order_id
4776 .map_or_else(|| report.venue_order_id.to_string(), |id| id.to_string());
4777 log::info!(
4778 color = LogColor::Blue as u8;
4779 "External order {} for {} claimed by strategy {}",
4780 order_id,
4781 report.instrument_id,
4782 claimed_strategy,
4783 );
4784
4785 (
4787 claimed_strategy,
4788 is_synthetic.then(|| vec![*TAG_RECONCILIATION]),
4789 )
4790 } else {
4791 let tag = if is_synthetic {
4793 *TAG_RECONCILIATION
4794 } else {
4795 *TAG_VENUE
4796 };
4797
4798 (StrategyId::from("EXTERNAL"), Some(vec![tag]))
4799 };
4800
4801 if self.config.filter_unclaimed_external && claimed_strategy.is_none() && !is_synthetic {
4803 return (Vec::new(), None);
4804 }
4805
4806 let client_order_id = report
4807 .client_order_id
4808 .unwrap_or_else(|| ClientOrderId::from(report.venue_order_id.as_str()));
4809
4810 if !report.quantity.is_positive() {
4811 log::error!(
4812 "Skipping external order {} ({}) for {}: non-positive quantity in report {:?}",
4813 client_order_id,
4814 report.venue_order_id,
4815 report.instrument_id,
4816 report,
4817 );
4818 return (Vec::new(), None);
4819 }
4820
4821 let ts_now = self.clock.borrow().timestamp_ns();
4822
4823 let Some(order_side) = report.order_side else {
4824 log::error!(
4825 "Skipping external order {} ({}) for {}: order side is not specified",
4826 client_order_id,
4827 report.venue_order_id,
4828 report.instrument_id,
4829 );
4830 return (Vec::new(), None);
4831 };
4832
4833 let initialized = match OrderInitialized::new_checked(
4834 self.config.trader_id,
4835 strategy_id,
4836 report.instrument_id,
4837 client_order_id,
4838 order_side,
4839 report.order_type,
4840 report.quantity,
4841 report.time_in_force,
4842 report.post_only,
4843 report.reduce_only,
4844 false, true, UUID4::new(),
4847 ts_now,
4848 ts_now,
4849 report.price,
4850 report.activation_price,
4851 report.trigger_price,
4852 report.trigger_type,
4853 report.limit_offset,
4854 report.trailing_offset,
4855 report.trailing_offset_type,
4856 report.expire_time,
4857 report.display_qty,
4858 None, None, report.contingency_type,
4861 report.order_list_id,
4862 report.linked_order_ids.clone(),
4863 report.parent_order_id,
4864 None, None, None, tags,
4868 ) {
4869 Ok(initialized) => initialized,
4870 Err(e) => {
4871 log::error!("Failed to create order from report: {e}");
4872 return (Vec::new(), None);
4873 }
4874 };
4875
4876 let initialized = OrderEventAny::Initialized(initialized);
4877
4878 let order = match OrderAny::from_events(vec![initialized.clone()]) {
4879 Ok(order) => order,
4880 Err(e) => {
4881 log::error!("Failed to create order from report: {e}");
4882 return (Vec::new(), None);
4883 }
4884 };
4885
4886 let replace_inferred_fill = !fills.is_empty()
4887 && matches!(
4888 report.order_status,
4889 OrderStatus::Accepted
4890 | OrderStatus::Canceled
4891 | OrderStatus::Expired
4892 | OrderStatus::Filled
4893 | OrderStatus::PartiallyFilled
4894 | OrderStatus::Triggered
4895 );
4896 let mut prepared_fills = Vec::new();
4897 let mut prepared_fill_keys = fill_queue
4898 .as_deref()
4899 .map(|queue| queue.pending_fill_keys.clone())
4900 .unwrap_or_default();
4901
4902 if replace_inferred_fill {
4903 let mut sorted_fills: Vec<&FillReport> = fills.to_vec();
4904 sorted_fills.sort_by_key(|fill| fill.ts_event);
4905
4906 if fill_queue.is_none() {
4907 log::error!(
4908 "Cannot reconcile external order {client_order_id}: fill queue is unavailable"
4909 );
4910 return (Vec::new(), None);
4911 }
4912
4913 for fill in sorted_fills {
4914 if let Some((fill_event, fill_key)) =
4915 self.create_order_fill(&order, fill, instrument, &prepared_fill_keys)
4916 {
4917 prepared_fill_keys.insert(fill_key);
4918 prepared_fills.push((fill_event, fill_key));
4919 }
4920 }
4921 }
4922
4923 let real_fill_total: Decimal = prepared_fills
4924 .iter()
4925 .map(|(fill, _)| fill.last_qty.as_decimal())
4926 .sum();
4927 let report_filled = report.filled_qty.as_decimal();
4928
4929 let inferred_qty = if report_filled.is_zero()
4930 || matches!(
4931 report.order_status,
4932 OrderStatus::Accepted | OrderStatus::Triggered
4933 ) {
4934 None
4935 } else if replace_inferred_fill {
4936 if real_fill_total < report_filled {
4937 match Quantity::from_decimal_dp(
4938 report_filled - real_fill_total,
4939 instrument.size_precision(),
4940 ) {
4941 Ok(quantity) => Some(quantity),
4942 Err(e) => {
4943 log::error!(
4944 "Cannot reconcile external order {client_order_id}: residual fill quantity is invalid: {e}"
4945 );
4946 return (Vec::new(), None);
4947 }
4948 }
4949 } else {
4950 None
4951 }
4952 } else if matches!(
4953 report.order_status,
4954 OrderStatus::PartiallyFilled
4955 | OrderStatus::Filled
4956 | OrderStatus::Canceled
4957 | OrderStatus::Expired
4958 | OrderStatus::Voided
4959 ) {
4960 Some(report.filled_qty)
4961 } else {
4962 None
4963 };
4964
4965 let requires_authoritative_fills =
4966 commission_client.is_some_and(ExecutionClient::requires_authoritative_fills);
4967 let defer_terminal = !is_synthetic
4968 && inferred_qty.is_some()
4969 && (requires_authoritative_fills
4970 || claimed_strategy.is_some()
4971 && matches!(
4972 report.order_status,
4973 OrderStatus::Canceled | OrderStatus::Expired
4974 ));
4975
4976 if defer_terminal && !requires_authoritative_fills && prepared_fills.is_empty() {
4977 log::warn!(
4978 "Deferring terminal reconciliation for claimed order {client_order_id}: fill reports are incomplete"
4979 );
4980 return (Vec::new(), None);
4981 }
4982
4983 if defer_terminal {
4984 log::warn!(
4985 "Deferring external order status for {client_order_id}: fill reports are incomplete"
4986 );
4987 }
4988
4989 let inferred_commission = if is_synthetic || defer_terminal {
4990 None
4991 } else if let Some(inferred_qty) = inferred_qty {
4992 let price_and_liquidity = inferred_fill_price_and_liquidity(&order, report, instrument);
4993
4994 match resolve_inferred_fill_commission(
4995 inferred_qty,
4996 price_and_liquidity,
4997 instrument,
4998 commission_client,
4999 ) {
5000 Ok(commission) => commission,
5001 Err(e) => {
5002 log::error!(
5003 "Deferring external order {client_order_id}: venue commission calculation failed: {e}"
5004 );
5005 return (Vec::new(), None);
5006 }
5007 }
5008 } else {
5009 None
5010 };
5011
5012 {
5013 let mut cache = self.cache.borrow_mut();
5014
5015 let source_client_id = if is_synthetic {
5016 None
5017 } else {
5018 commission_client.map(ExecutionClient::client_id)
5019 };
5020
5021 if let Err(e) = cache.add_order(order.clone(), None, source_client_id, false) {
5022 match cache.order(&client_order_id) {
5026 Some(existing) if is_synthetic && existing.is_closed() => {
5027 log::debug!(
5028 "Skipping synthetic reconciliation order {client_order_id} for {}: \
5029 replay deduped (cached status={:?})",
5030 report.instrument_id,
5031 existing.status(),
5032 );
5033 }
5034 Some(existing) if is_synthetic => {
5035 log::warn!(
5036 "Synthetic reconciliation order {client_order_id} for {} exists in \
5037 cache in non-terminal state {:?}; fill not regenerated",
5038 report.instrument_id,
5039 existing.status(),
5040 );
5041 }
5042 _ => {
5043 log::error!("Failed to add external order to cache: {e}");
5044 }
5045 }
5046
5047 return (Vec::new(), None);
5048 }
5049
5050 if let Err(e) = cache.index_venue_order_id(&client_order_id, &report.venue_order_id) {
5051 log::warn!("Failed to index venue order ID: {e}");
5052 }
5053 }
5054
5055 Self::publish_order_event(&initialized);
5056
5057 log::info!(
5058 color = LogColor::Blue as u8;
5059 "Created external order {} ({}) for {} [{}]",
5060 client_order_id,
5061 report.venue_order_id,
5062 report.instrument_id,
5063 report.order_status,
5064 );
5065
5066 let ts_now = self.clock.borrow().timestamp_ns();
5067 let mut order_events = generate_external_order_status_events_with_commission(
5068 &order,
5069 report,
5070 &account_id,
5071 instrument,
5072 ts_now,
5073 inferred_commission,
5074 );
5075
5076 if defer_terminal && requires_authoritative_fills {
5077 order_events.retain(|event| matches!(event, OrderEventAny::Accepted(_)));
5078 }
5079
5080 if replace_inferred_fill {
5081 let terminal_event = order_events.pop_if(|event| {
5082 matches!(
5083 event,
5084 OrderEventAny::Canceled(_) | OrderEventAny::Expired(_),
5085 )
5086 });
5087
5088 order_events.pop_if(|event| matches!(event, OrderEventAny::Filled(_)));
5089
5090 let fill_queue =
5091 fill_queue.expect("fill queue availability was checked before cache mutation");
5092 for (fill_event, fill_key) in prepared_fills {
5093 fill_queue.push(&mut order_events, fill_event, fill_key);
5094 }
5095
5096 if !defer_terminal
5097 && let Some(inferred_qty) = inferred_qty
5098 && let Some(inferred_fill) = create_inferred_fill_for_qty(
5099 &order,
5100 report,
5101 &account_id,
5102 instrument,
5103 inferred_qty,
5104 ts_now,
5105 inferred_commission,
5106 )
5107 {
5108 order_events.push(inferred_fill);
5109 }
5110
5111 if !defer_terminal && let Some(event) = terminal_event {
5112 order_events.push(event);
5113 }
5114 }
5115
5116 let metadata = ExternalOrderMetadata {
5117 client_order_id,
5118 venue_order_id: report.venue_order_id,
5119 instrument_id: report.instrument_id,
5120 strategy_id,
5121 ts_init: ts_now,
5122 };
5123
5124 (order_events, Some(metadata))
5125 }
5126
5127 fn publish_order_event(event: &OrderEventAny) {
5128 let topic = switchboard::get_event_order_topic(event.strategy_id());
5129 msgbus::publish_order_event(topic, event);
5130 }
5131
5132 fn adjust_mass_status_fills(&self, mass_status: &ExecutionMassStatus) -> AdjustedReports {
5137 let mut final_orders: IndexMap<VenueOrderId, OrderStatusReport> =
5138 mass_status.order_reports();
5139 let mut final_fills: IndexMap<VenueOrderId, Vec<FillReport>> = mass_status.fill_reports();
5140 let mut order_only_ids = IndexSet::new();
5141 let mut order_only_fill_keys = IndexSet::new();
5142
5143 final_fills.retain(|_, fills| {
5144 fills.retain(|fill| {
5145 if fill.last_qty.is_zero() {
5146 log::warn!("Skipping zero-quantity fill report: {fill}");
5147 return false;
5148 }
5149
5150 true
5151 });
5152
5153 !fills.is_empty()
5154 });
5155
5156 if self.config.filter_position_reports {
5157 return AdjustedReports {
5158 orders: final_orders,
5159 fills: final_fills,
5160 order_only_ids,
5161 order_only_fill_keys,
5162 };
5163 }
5164
5165 let mut instruments_to_adjust = Vec::new();
5166
5167 for (instrument_id, position_reports) in mass_status.position_reports() {
5168 if !self.should_reconcile_instrument(&instrument_id) {
5169 log::debug!(
5170 "Skipping fill adjustment for {instrument_id}: not in reconciliation_instrument_ids"
5171 );
5172 continue;
5173 }
5174
5175 let is_hedge_mode = position_reports
5178 .iter()
5179 .any(|r| r.venue_position_id.is_some());
5180
5181 if is_hedge_mode {
5182 log::debug!(
5183 "Skipping fill adjustment for {instrument_id}: hedge mode (has venue_position_id)"
5184 );
5185 continue;
5186 }
5187
5188 let has_retained_position = {
5189 let cache = self.cache.borrow();
5190 !cache
5191 .positions_open(
5192 None,
5193 Some(&instrument_id),
5194 None,
5195 Some(&mass_status.account_id),
5196 None,
5197 )
5198 .is_empty()
5199 };
5200
5201 if has_retained_position {
5202 log::debug!(
5203 "Skipping fill adjustment for {instrument_id}: retained open position in cache"
5204 );
5205 continue;
5206 }
5207
5208 if let Some(instrument) = self.get_instrument(&instrument_id) {
5209 instruments_to_adjust.push(instrument);
5210 } else {
5211 log::debug!(
5212 "Skipping fill adjustment for {instrument_id}: instrument not found in cache"
5213 );
5214 }
5215 }
5216
5217 if instruments_to_adjust.is_empty() {
5218 return AdjustedReports {
5219 orders: final_orders,
5220 fills: final_fills,
5221 order_only_ids,
5222 order_only_fill_keys,
5223 };
5224 }
5225
5226 log_info!(
5227 "Adjusting fills for {} instrument(s) with position reports",
5228 instruments_to_adjust.len(),
5229 color = LogColor::Blue
5230 );
5231
5232 for instrument in &instruments_to_adjust {
5233 let instrument_id = instrument.id();
5234 let result = if self.config.generate_missing_orders {
5235 process_mass_status_for_reconciliation(mass_status, instrument, None)
5236 } else {
5237 process_mass_status_for_reconciliation_without_synthetic_reports(
5238 mass_status,
5239 instrument,
5240 None,
5241 )
5242 };
5243
5244 match result {
5245 Ok(result) => {
5246 order_only_ids.extend(result.order_only_ids);
5247 order_only_fill_keys.extend(result.order_only_fill_keys);
5248 final_orders.retain(|_, order| order.instrument_id != instrument_id);
5249 final_fills.retain(|_, fills| {
5250 fills
5251 .first()
5252 .is_none_or(|f| f.instrument_id != instrument_id)
5253 });
5254
5255 final_orders.extend(result.orders);
5256 final_fills.extend(result.fills);
5257 }
5258 Err(e) => {
5259 log::warn!("Failed to adjust fills for {instrument_id}: {e}");
5260 }
5261 }
5262 }
5263
5264 log_info!(
5265 "After adjustment: {} order(s), {} fill group(s)",
5266 final_orders.len(),
5267 final_fills.len(),
5268 color = LogColor::Blue
5269 );
5270
5271 AdjustedReports {
5272 orders: final_orders,
5273 fills: final_fills,
5274 order_only_ids,
5275 order_only_fill_keys,
5276 }
5277 }
5278
5279 fn applied_fill_key(&self, fill: &OrderFilled) -> Option<FillKey> {
5280 if fill.last_qty.is_zero() {
5281 return None;
5282 }
5283
5284 let cache = self.cache();
5285 let order = cache.order(&fill.client_order_id).or_else(|| {
5286 cache
5287 .client_order_id(&fill.venue_order_id)
5288 .and_then(|client_order_id| cache.order(client_order_id))
5289 })?;
5290
5291 order.trade_ids().contains(&&fill.trade_id).then_some((
5292 order.account_id()?,
5293 order.instrument_id(),
5294 fill.trade_id,
5295 ))
5296 }
5297
5298 fn create_order_fill(
5299 &self,
5300 order: &OrderAny,
5301 fill: &FillReport,
5302 instrument: &InstrumentAny,
5303 pending_fill_keys: &IndexSet<FillKey>,
5304 ) -> Option<(OrderFilled, FillKey)> {
5305 if fill.last_qty.is_zero() {
5306 log::warn!("Skipping zero-quantity fill report: {fill}");
5307 return None;
5308 }
5309
5310 let fill_key = (fill.account_id, fill.instrument_id, fill.trade_id);
5311 if self.fills_processed.contains_key(&fill_key) || pending_fill_keys.contains(&fill_key) {
5312 return None;
5313 }
5314
5315 let order_side = order.order_side();
5316 if fill.order_side != order_side {
5317 log::warn!(
5318 "Fill side mismatch for {}: cached={:?}, venue={:?}",
5319 order.client_order_id(),
5320 order_side,
5321 fill.order_side,
5322 );
5323 }
5324
5325 let ts_now = self.clock.borrow().timestamp_ns();
5326
5327 let event = OrderFilled::new(
5328 order.trader_id(),
5329 order.strategy_id(),
5330 order.instrument_id(),
5331 order.client_order_id(),
5332 fill.venue_order_id,
5333 fill.account_id,
5334 fill.trade_id,
5335 fill.order_side,
5336 order.order_type(),
5337 fill.last_qty,
5338 fill.last_px,
5339 instrument.quote_currency(),
5340 fill.liquidity_side,
5341 fill.report_id,
5342 fill.ts_event,
5343 ts_now,
5344 true, fill.venue_position_id,
5346 Some(fill.commission),
5347 None,
5348 );
5349
5350 Some((event, fill_key))
5351 }
5352}
5353
5354fn position_fill_report_matches(
5355 cache: &Cache,
5356 report: &FillReport,
5357 positions: &[PositionRef<'_>],
5358 mut flip_for_order: impl FnMut(ClientOrderId) -> anyhow::Result<Option<[PositionId; 2]>>,
5359 mut replay: Option<&mut IndexMap<PositionId, IndexMap<TradeId, Vec<usize>>>>,
5360) -> bool {
5361 let client_order_id = report
5362 .client_order_id
5363 .or_else(|| cache.client_order_id(&report.venue_order_id).copied());
5364
5365 let flip = match client_order_id.map(&mut flip_for_order).transpose() {
5366 Ok(flip) => flip.flatten(),
5367 Err(_) => return false,
5368 };
5369
5370 if let (Some(ids), Some(id)) = (flip, report.venue_position_id)
5371 && !ids.contains(&id)
5372 {
5373 return false;
5374 }
5375
5376 let mut matched = false;
5377 let mut quantity = Quantity::zero(report.last_qty.precision);
5378 let mut commission = Money::zero(report.commission.currency);
5379
5380 for position in positions {
5381 if flip.map_or_else(
5382 || report.venue_position_id.is_some_and(|id| position.id != id),
5383 |ids| !ids.contains(&position.id),
5384 ) {
5385 continue;
5386 }
5387
5388 let totals = if let Some(replay) = replay.as_deref_mut() {
5389 let indexes = replay
5390 .entry(position.id)
5391 .or_insert_with(|| position_fill_report_indexes(position))
5392 .get(&report.trade_id);
5393 position_fill_report_totals(
5394 position,
5395 report,
5396 client_order_id,
5397 flip.is_some(),
5398 indexes
5399 .into_iter()
5400 .flatten()
5401 .map(|&index| &position.replay_events[index]),
5402 )
5403 } else {
5404 position_fill_report_totals(
5405 position,
5406 report,
5407 client_order_id,
5408 flip.is_some(),
5409 position.replay_events.iter(),
5410 )
5411 };
5412
5413 let Some((position_quantity, position_commission)) = totals else {
5414 return false;
5415 };
5416
5417 let Some(next_quantity) = quantity.checked_add(position_quantity) else {
5418 return false;
5419 };
5420
5421 let Some(next_commission) = commission.checked_add(position_commission) else {
5422 return false;
5423 };
5424
5425 matched |= position_quantity.non_zero();
5426 quantity = next_quantity;
5427 commission = next_commission;
5428 }
5429
5430 matched && quantity == report.last_qty && commission == report.commission
5431}
5432
5433fn position_fill_report_indexes(position: &Position) -> IndexMap<TradeId, Vec<usize>> {
5434 let mut replay = IndexMap::<_, Vec<usize>>::new();
5435
5436 for (index, event) in position.replay_events.iter().enumerate() {
5437 if let PositionReplayEvent::Filled(fill) = event {
5438 replay.entry(fill.trade_id).or_default().push(index);
5439 }
5440 }
5441
5442 replay
5443}
5444
5445fn position_fill_report_totals<'a>(
5446 position: &Position,
5447 report: &FillReport,
5448 client_order_id: Option<ClientOrderId>,
5449 apply_voids: bool,
5450 replay: impl Iterator<Item = &'a PositionReplayEvent>,
5451) -> Option<(Quantity, Money)> {
5452 let mut fills = replay.filter_map(|event| match event {
5453 PositionReplayEvent::Filled(fill)
5454 if fill.position_id == Some(position.id)
5455 && fill.account_id == report.account_id
5456 && fill.instrument_id == report.instrument_id
5457 && fill.venue_order_id == report.venue_order_id
5458 && fill.trade_id == report.trade_id
5459 && fill.order_side == report.order_side
5460 && fill.last_px == report.last_px
5461 && fill.liquidity_side == report.liquidity_side
5462 && client_order_id.is_none_or(|id| fill.client_order_id == id) =>
5463 {
5464 Some(fill)
5465 }
5466 _ => None,
5467 });
5468
5469 let (mut position_quantity, mut position_commission) = fills.try_fold(
5470 (
5471 Quantity::zero(report.last_qty.precision),
5472 Money::zero(report.commission.currency),
5473 ),
5474 |(quantity, commission), fill| {
5475 let fill_commission = fill.commission?;
5476 if fill_commission.currency != report.commission.currency {
5477 return None;
5478 }
5479
5480 Some((
5481 quantity.checked_add(fill.last_qty)?,
5482 commission.checked_add(fill_commission)?,
5483 ))
5484 },
5485 )?;
5486
5487 if apply_voids
5488 && let Some(correction) = position.fill_voids.iter().rev().find(|correction| {
5489 correction.event.trade_id == report.trade_id
5490 && correction.event.venue_order_id == report.venue_order_id
5491 && client_order_id.is_none_or(|id| correction.event.client_order_id == id)
5492 })
5493 {
5494 let corrected_quantity = position_quantity.checked_sub(correction.voided_qty)?;
5495 let corrected_commission = position_commission.checked_sub(
5496 correction
5497 .commission_voided
5498 .unwrap_or(Money::zero(report.commission.currency)),
5499 )?;
5500 position_quantity = corrected_quantity;
5501 position_commission = corrected_commission;
5502 }
5503
5504 Some((position_quantity, position_commission))
5505}
5506
5507#[cfg(test)]
5508mod tests {
5509 use nautilus_common::{clock::VirtualClock, config::ConfigError};
5510 use nautilus_core::{DurationNanos, Params};
5511 use nautilus_execution::reconciliation::generate_reconciliation_order_events;
5512 use nautilus_model::{
5513 accounts::AccountAny,
5514 enums::{LiquiditySide, OmsType, OrderType, PositionSide, TimeInForce},
5515 events::order::spec::{
5516 OrderCancelDeniedSpec, OrderModifyDeniedSpec, OrderPendingCancelSpec,
5517 OrderPendingUpdateSpec, OrderUpdatedSpec,
5518 },
5519 identifiers::{Symbol, Venue},
5520 instruments::{
5521 CurrencyPair, Instrument,
5522 stubs::{btcusd_bybit, crypto_perpetual_ethusdt},
5523 },
5524 orders::{OrderTestBuilder, stubs::TestOrderEventStubs},
5525 types::{AccountBalance, Currency, MarginBalance, Money, Price, fixed::FIXED_PRECISION},
5526 };
5527 use rstest::rstest;
5528 use rust_decimal_macros::dec;
5529
5530 use super::{
5531 super::reconciliation::tests::{CommissionOutcome, CommissionStubClient},
5532 *,
5533 };
5534
5535 #[rstest]
5536 fn test_new_validates_open_check_lookback_mins_boundaries() {
5537 let create_manager = |mins| {
5538 ExecutionManager::new(
5539 Rc::new(RefCell::new(VirtualClock::new())),
5540 Rc::new(RefCell::new(Cache::default())),
5541 ExecutionManagerConfig {
5542 open_check_lookback_mins: Some(mins),
5543 ..Default::default()
5544 },
5545 )
5546 };
5547
5548 assert!(create_manager(307_445_734).is_ok());
5549 assert!(matches!(
5550 create_manager(307_445_735),
5551 Err(ConfigError::Range { field, .. })
5552 if field == "ExecutionManagerConfig.open_check_lookback_mins"
5553 ));
5554 }
5555
5556 #[rstest]
5557 fn test_new_validates_reconciliation_lookback_mins_boundaries() {
5558 let create_manager = |mins| {
5559 ExecutionManager::new(
5560 Rc::new(RefCell::new(VirtualClock::new())),
5561 Rc::new(RefCell::new(Cache::default())),
5562 ExecutionManagerConfig {
5563 lookback_mins: Some(mins),
5564 ..Default::default()
5565 },
5566 )
5567 };
5568
5569 assert!(create_manager(307_445_734_561_825_860).is_ok());
5570 assert!(matches!(
5571 create_manager(307_445_734_561_825_861),
5572 Err(ConfigError::Range { field, .. })
5573 if field == "ExecutionManagerConfig.lookback_mins"
5574 ));
5575 }
5576
5577 #[rstest]
5578 fn test_new_reports_every_invalid_lookback_field() {
5579 let error = ExecutionManager::new(
5580 Rc::new(RefCell::new(VirtualClock::new())),
5581 Rc::new(RefCell::new(Cache::default())),
5582 ExecutionManagerConfig {
5583 lookback_mins: Some(307_445_734_561_825_861),
5584 open_check_lookback_mins: Some(307_445_735),
5585 position_check_lookback_mins: 307_445_735,
5586 ..Default::default()
5587 },
5588 )
5589 .expect_err("all lookback fields are out of range");
5590
5591 let ConfigError::Multiple { errors } = error else {
5592 panic!("expected a `Multiple` error, was {error:?}");
5593 };
5594
5595 let fields = errors
5596 .iter()
5597 .map(|e| match e {
5598 ConfigError::Range { field, .. } => field.as_str(),
5599 other => panic!("expected a `Range` error, was {other:?}"),
5600 })
5601 .collect::<Vec<_>>();
5602
5603 assert_eq!(
5604 fields,
5605 [
5606 "ExecutionManagerConfig.lookback_mins",
5607 "ExecutionManagerConfig.open_check_lookback_mins",
5608 "ExecutionManagerConfig.position_check_lookback_mins",
5609 ]
5610 );
5611 }
5612
5613 struct PositionCoverageStubClient;
5614
5615 #[async_trait::async_trait(?Send)]
5616 impl ExecutionClient for PositionCoverageStubClient {
5617 fn is_connected(&self) -> bool {
5618 true
5619 }
5620
5621 fn client_id(&self) -> ClientId {
5622 ClientId::from("BYBIT")
5623 }
5624
5625 fn account_id(&self) -> AccountId {
5626 AccountId::from("TEST-001")
5627 }
5628
5629 fn venue(&self) -> Venue {
5630 Venue::from("BYBIT")
5631 }
5632
5633 fn oms_type(&self) -> OmsType {
5634 OmsType::Netting
5635 }
5636
5637 fn get_account(&self) -> Option<AccountAny> {
5638 None
5639 }
5640
5641 fn provides_bulk_position_coverage(&self, instrument_id: InstrumentId) -> bool {
5642 !instrument_id.symbol.as_str().ends_with("-SPOT")
5643 }
5644
5645 fn generate_account_state(
5646 &self,
5647 _balances: Vec<AccountBalance>,
5648 _margins: Vec<MarginBalance>,
5649 _reported: bool,
5650 _ts_event: UnixNanos,
5651 _info: Option<Params>,
5652 ) -> anyhow::Result<()> {
5653 Ok(())
5654 }
5655
5656 fn start(&mut self) -> anyhow::Result<()> {
5657 Ok(())
5658 }
5659
5660 fn stop(&mut self) -> anyhow::Result<()> {
5661 Ok(())
5662 }
5663 }
5664
5665 fn cached_commission_fixtures() -> (
5666 ExecutionManager,
5667 Rc<RefCell<Cache>>,
5668 OrderAny,
5669 OrderStatusReport,
5670 InstrumentAny,
5671 ) {
5672 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
5673 let clock = Rc::new(RefCell::new(VirtualClock::new()));
5674 let cache = Rc::new(RefCell::new(Cache::default()));
5675 cache
5676 .borrow_mut()
5677 .add_instrument(instrument.clone())
5678 .expect("instrument is cacheable");
5679 let client_order_id = ClientOrderId::from("O-COMMISSION-CACHED");
5680 let venue_order_id = VenueOrderId::from("V-COMMISSION-CACHED");
5681 insert_accepted_limit_order(
5682 &cache,
5683 client_order_id,
5684 venue_order_id,
5685 instrument.id(),
5686 ClientId::from("STUB"),
5687 );
5688 let order = cache
5689 .borrow()
5690 .order_owned(&client_order_id)
5691 .expect("accepted order is cached");
5692 let report = OrderStatusReport::new(
5693 AccountId::from("TEST-001"),
5694 instrument.id(),
5695 Some(client_order_id),
5696 venue_order_id,
5697 OrderSide::Buy.into(),
5698 OrderType::Limit,
5699 TimeInForce::Gtc,
5700 OrderStatus::Filled,
5701 Quantity::from("10.0"),
5702 Quantity::from("10.0"),
5703 UnixNanos::from(1),
5704 UnixNanos::from(1),
5705 UnixNanos::from(1),
5706 None,
5707 )
5708 .with_avg_px(dec!(100.0));
5709 let manager =
5710 ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
5711 .expect("valid config");
5712
5713 (manager, cache, order, report, instrument)
5714 }
5715
5716 fn external_report_with_partial_fill(
5717 instrument: &InstrumentAny,
5718 ) -> (OrderStatusReport, FillReport) {
5719 let account_id = AccountId::from("STUB-001");
5720 let venue_order_id = VenueOrderId::from("V-EXT-1");
5721 let report = OrderStatusReport::new(
5722 account_id,
5723 instrument.id(),
5724 None,
5725 venue_order_id,
5726 OrderSide::Buy.into(),
5727 OrderType::Limit,
5728 TimeInForce::Gtc,
5729 OrderStatus::Filled,
5730 Quantity::from("10.0"),
5731 Quantity::from("10.0"),
5732 UnixNanos::from(1),
5733 UnixNanos::from(1),
5734 UnixNanos::from(1),
5735 None,
5736 )
5737 .with_price(Price::from("100.00"))
5738 .with_avg_px(dec!(100.0));
5739
5740 let fill = FillReport::new(
5741 account_id,
5742 instrument.id(),
5743 venue_order_id,
5744 TradeId::from("T-EXT-1"),
5745 OrderSide::Buy,
5746 Quantity::from("4.0"),
5747 Price::from("100.00"),
5748 Money::new(0.1, Currency::USDT()),
5749 LiquiditySide::Taker,
5750 None,
5751 None,
5752 UnixNanos::from(1),
5753 UnixNanos::from(1),
5754 None,
5755 );
5756
5757 (report, fill)
5758 }
5759
5760 fn inferred_fills(events: &[OrderEventAny]) -> Vec<OrderFilled> {
5761 events
5762 .iter()
5763 .filter_map(|event| match event {
5764 OrderEventAny::Filled(filled) if filled.last_qty == Quantity::from("6.0") => {
5765 Some(filled.clone())
5766 }
5767 _ => None,
5768 })
5769 .collect()
5770 }
5771
5772 #[rstest]
5773 fn test_handle_external_order_applies_venue_commission_to_inferred_fill() {
5774 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
5775 let clock = Rc::new(RefCell::new(VirtualClock::new()));
5776 let cache = Rc::new(RefCell::new(Cache::default()));
5777 cache
5778 .borrow_mut()
5779 .add_instrument(instrument.clone())
5780 .expect("instrument is cacheable");
5781 let manager = ExecutionManager::new(clock, cache, ExecutionManagerConfig::default())
5782 .expect("valid config");
5783 let (report, fill) = external_report_with_partial_fill(&instrument);
5784 let expected = Money::new(2.5, Currency::USDT());
5785 let client = CommissionStubClient::new(CommissionOutcome::Value(expected));
5786 let mut fill_queue = ReconciliationFillQueue::default();
5787
5788 let (events, _) = manager.handle_external_order(
5789 &report,
5790 AccountId::from("STUB-001"),
5791 &instrument,
5792 &[&fill],
5793 false,
5794 Some(&mut fill_queue),
5795 Some(&client),
5796 );
5797
5798 let inferred = inferred_fills(&events);
5799 assert_eq!(inferred.len(), 1, "one inferred fill covers the 6.0 gap");
5800 assert_eq!(inferred[0].commission, Some(expected));
5801 }
5802
5803 #[rstest]
5804 fn test_submitted_order_accepts_status_without_authoritative_fills(
5805 #[values(false, true)] is_snapshot: bool,
5806 ) {
5807 let (mut manager, _cache, order, report, instrument) = cached_commission_fixtures();
5808 let mut submitted =
5809 OrderAny::from_events(order.events().into_iter().take(2).cloned().collect()).unwrap();
5810 assert_eq!(submitted.status(), OrderStatus::Submitted);
5811 let mut client = CommissionStubClient::new(CommissionOutcome::Failure);
5812 client.requires_authoritative_fills = true;
5813 let mut queue = ReconciliationFillQueue::default();
5814
5815 let events = manager.reconcile_order_with_fills(
5816 is_snapshot,
5817 &submitted,
5818 &report,
5819 &[],
5820 Some(&instrument),
5821 &mut queue,
5822 Some(&client),
5823 );
5824
5825 assert_eq!(events.len(), 1);
5826 assert!(matches!(events[0], OrderEventAny::Accepted(_)));
5827 submitted.apply(events[0].clone()).unwrap();
5828 assert_eq!(submitted.status(), OrderStatus::Accepted);
5829 assert_eq!(submitted.quantity(), report.quantity);
5830 assert_eq!(submitted.filled_qty(), Quantity::from("0.0"));
5831 assert_eq!(submitted.venue_order_id(), Some(report.venue_order_id));
5832 assert!(submitted.trade_ids().is_empty());
5833 assert!(submitted.commissions().is_empty());
5834 assert_eq!(client.seen(), None);
5835 }
5836
5837 #[rstest]
5838 fn test_external_order_defers_missing_authoritative_fills(
5839 #[values(0, 4, 10)] recovered_qty: u32,
5840 #[values(
5841 OrderStatus::PartiallyFilled,
5842 OrderStatus::Filled,
5843 OrderStatus::Canceled
5844 )]
5845 status: OrderStatus,
5846 ) {
5847 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
5848 let cache = Rc::new(RefCell::new(Cache::default()));
5849 cache
5850 .borrow_mut()
5851 .add_instrument(instrument.clone())
5852 .unwrap();
5853 let manager = ExecutionManager::new(
5854 Rc::new(RefCell::new(VirtualClock::new())),
5855 Rc::clone(&cache),
5856 ExecutionManagerConfig::default(),
5857 )
5858 .unwrap();
5859 let (mut report, mut fill) = external_report_with_partial_fill(&instrument);
5860 report.order_status = status;
5861 if status != OrderStatus::Filled {
5862 report.quantity = Quantity::from("20.0");
5863 }
5864
5865 fill.last_qty = Quantity::from_decimal_dp(Decimal::from(recovered_qty), 1).unwrap();
5866
5867 let reports = if recovered_qty == 0 {
5868 vec![]
5869 } else {
5870 vec![&fill]
5871 };
5872
5873 let mut client =
5874 CommissionStubClient::new(CommissionOutcome::Value(Money::from("2.5 USDT")));
5875 client.requires_authoritative_fills = true;
5876 let mut queue = ReconciliationFillQueue::default();
5877 let (events, metadata) = manager.handle_external_order(
5878 &report,
5879 report.account_id,
5880 &instrument,
5881 &reports,
5882 false,
5883 Some(&mut queue),
5884 Some(&client),
5885 );
5886
5887 let fills = events
5888 .iter()
5889 .filter_map(|event| {
5890 if let OrderEventAny::Filled(fill) = event {
5891 Some(fill)
5892 } else {
5893 None
5894 }
5895 })
5896 .collect::<Vec<_>>();
5897
5898 assert_eq!(client.seen(), None);
5899
5900 assert_eq!(fills.len(), usize::from(recovered_qty != 0));
5901
5902 if recovered_qty != 0 {
5903 assert_eq!(fills[0].trade_id, fill.trade_id);
5904 assert_eq!(fills[0].last_qty, fill.last_qty);
5905 assert_eq!(fills[0].last_px, fill.last_px);
5906 assert_eq!(fills[0].commission, Some(fill.commission));
5907 }
5908
5909 let metadata = metadata.unwrap();
5910 assert_eq!(metadata.venue_order_id, report.venue_order_id);
5911 assert_eq!(events[0].client_order_id(), metadata.client_order_id);
5912 assert!(matches!(events[0], OrderEventAny::Accepted(_)));
5913
5914 for event in &events {
5915 cache.borrow_mut().update_order(event).unwrap();
5916 }
5917
5918 let cache = cache.borrow();
5919 let order = cache.order(&metadata.client_order_id).unwrap();
5920 assert_eq!(order.quantity(), report.quantity);
5921 assert_eq!(order.filled_qty(), fill.last_qty);
5922 assert_eq!(order.order_side(), report.order_side.unwrap());
5923 assert_eq!(order.order_type(), report.order_type);
5924 assert_eq!(order.price(), report.price);
5925 assert_eq!(order.venue_order_id(), Some(report.venue_order_id));
5926 assert_eq!(order.account_id(), Some(report.account_id));
5927 assert_eq!(
5928 order.status(),
5929 if recovered_qty == 0 {
5930 OrderStatus::Accepted
5931 } else if recovered_qty == 10 {
5932 status
5933 } else {
5934 OrderStatus::PartiallyFilled
5935 },
5936 );
5937 assert_eq!(
5938 order.commissions().get(&fill.commission.currency),
5939 if recovered_qty == 0 {
5940 None
5941 } else {
5942 Some(&fill.commission)
5943 },
5944 );
5945 assert_eq!(
5946 order.trade_ids(),
5947 if recovered_qty == 0 {
5948 vec![]
5949 } else {
5950 vec![&fill.trade_id]
5951 },
5952 );
5953 }
5954
5955 #[rstest]
5956 fn test_handle_external_order_skips_inferred_fill_when_commission_fails() {
5957 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
5958 let clock = Rc::new(RefCell::new(VirtualClock::new()));
5959 let cache = Rc::new(RefCell::new(Cache::default()));
5960 cache
5961 .borrow_mut()
5962 .add_instrument(instrument.clone())
5963 .expect("instrument is cacheable");
5964 let manager =
5965 ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
5966 .expect("valid config");
5967 let (report, fill) = external_report_with_partial_fill(&instrument);
5968 let client = CommissionStubClient::new(CommissionOutcome::Failure);
5969 let mut fill_queue = ReconciliationFillQueue::default();
5970
5971 let (events, metadata) = manager.handle_external_order(
5972 &report,
5973 AccountId::from("STUB-001"),
5974 &instrument,
5975 &[&fill],
5976 false,
5977 Some(&mut fill_queue),
5978 Some(&client),
5979 );
5980
5981 assert!(events.is_empty());
5982 assert!(metadata.is_none());
5983 assert!(fill_queue.pending_fill_keys.is_empty());
5984 assert!(
5985 cache
5986 .borrow()
5987 .order(&ClientOrderId::from(report.venue_order_id.as_str()))
5988 .is_none(),
5989 "commission failure must precede external order cache mutation"
5990 );
5991
5992 let expected = Money::new(2.5, Currency::USDT());
5993 let retry_client = CommissionStubClient::new(CommissionOutcome::Value(expected));
5994 let (retry_events, retry_metadata) = manager.handle_external_order(
5995 &report,
5996 AccountId::from("STUB-001"),
5997 &instrument,
5998 &[&fill],
5999 false,
6000 Some(&mut fill_queue),
6001 Some(&retry_client),
6002 );
6003 let inferred = inferred_fills(&retry_events);
6004
6005 assert!(retry_metadata.is_some());
6006 assert_eq!(inferred.len(), 1);
6007 assert_eq!(inferred[0].commission, Some(expected));
6008 assert_eq!(fill_queue.pending_fill_keys.len(), 1);
6009 assert!(
6010 cache
6011 .borrow()
6012 .order(&ClientOrderId::from(report.venue_order_id.as_str()))
6013 .is_some()
6014 );
6015 }
6016
6017 #[rstest]
6018 fn test_handle_external_order_without_explicit_fills_resolves_commission_before_cache() {
6019 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
6020 let clock = Rc::new(RefCell::new(VirtualClock::new()));
6021 let cache = Rc::new(RefCell::new(Cache::default()));
6022 cache
6023 .borrow_mut()
6024 .add_instrument(instrument.clone())
6025 .expect("instrument is cacheable");
6026 let manager =
6027 ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
6028 .expect("valid config");
6029 let (report, _) = external_report_with_partial_fill(&instrument);
6030 let failing_client = CommissionStubClient::new(CommissionOutcome::Failure);
6031
6032 let (failed_events, failed_metadata) = manager.handle_external_order(
6033 &report,
6034 AccountId::from("STUB-001"),
6035 &instrument,
6036 &[],
6037 false,
6038 None,
6039 Some(&failing_client),
6040 );
6041
6042 assert!(failed_events.is_empty());
6043 assert!(failed_metadata.is_none());
6044 assert!(
6045 cache
6046 .borrow()
6047 .order(&ClientOrderId::from(report.venue_order_id.as_str()))
6048 .is_none()
6049 );
6050
6051 let expected = Money::new(4.0, Currency::USDT());
6052 let retry_client = CommissionStubClient::new(CommissionOutcome::Value(expected));
6053 let (retry_events, retry_metadata) = manager.handle_external_order(
6054 &report,
6055 AccountId::from("STUB-001"),
6056 &instrument,
6057 &[],
6058 false,
6059 None,
6060 Some(&retry_client),
6061 );
6062
6063 let fills: Vec<_> = retry_events
6064 .iter()
6065 .filter_map(|event| match event {
6066 OrderEventAny::Filled(fill) => Some(fill),
6067 _ => None,
6068 })
6069 .collect();
6070
6071 assert!(retry_metadata.is_some());
6072 assert_eq!(fills.len(), 1);
6073 assert_eq!(fills[0].last_qty, Quantity::from("10.0"));
6074 assert_eq!(fills[0].commission, Some(expected));
6075 }
6076
6077 #[rstest]
6078 fn test_handle_external_order_with_no_override_emits_fill_without_commission() {
6079 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
6080 let clock = Rc::new(RefCell::new(VirtualClock::new()));
6081 let cache = Rc::new(RefCell::new(Cache::default()));
6082 cache
6083 .borrow_mut()
6084 .add_instrument(instrument.clone())
6085 .expect("instrument is cacheable");
6086 let manager = ExecutionManager::new(clock, cache, ExecutionManagerConfig::default())
6087 .expect("valid config");
6088 let (report, fill) = external_report_with_partial_fill(&instrument);
6089 let client = CommissionStubClient::new(CommissionOutcome::NoOverride);
6090 let mut fill_queue = ReconciliationFillQueue::default();
6091
6092 let (events, _) = manager.handle_external_order(
6093 &report,
6094 AccountId::from("STUB-001"),
6095 &instrument,
6096 &[&fill],
6097 false,
6098 Some(&mut fill_queue),
6099 Some(&client),
6100 );
6101
6102 let inferred = inferred_fills(&events);
6103 assert_eq!(inferred.len(), 1);
6104 assert_eq!(inferred[0].commission, None);
6105 }
6106
6107 #[rstest]
6108 #[case::filled(
6109 OrderStatus::Filled,
6110 "10.0",
6111 "6.0",
6112 Price::from_decimal_dp(dec!(33.3333333333333333), FIXED_PRECISION).unwrap(),
6113 1
6114 )]
6115 #[case::canceled(OrderStatus::Canceled, "8.0", "4.0", "20.00", 2)]
6116 #[case::expired(OrderStatus::Expired, "8.0", "4.0", "20.00", 2)]
6117 fn test_cached_reconciliation_applies_explicit_fill_and_defers_failed_residual(
6118 #[case] status: OrderStatus,
6119 #[case] filled_qty: Quantity,
6120 #[case] residual_qty: Quantity,
6121 #[case] residual_px: Price,
6122 #[case] event_count: usize,
6123 ) {
6124 let (mut manager, _cache, order, mut report, instrument) = cached_commission_fixtures();
6125 report.order_status = status;
6126 report.filled_qty = filled_qty;
6127 report.avg_px = Some(dec!(60.0));
6128
6129 let explicit_fill = FillReport::new(
6130 report.account_id,
6131 report.instrument_id,
6132 report.venue_order_id,
6133 TradeId::from("T-COMMISSION-EXPLICIT"),
6134 OrderSide::Buy,
6135 Quantity::from("4.0"),
6136 Price::from("100.0"),
6137 Money::new(0.25, Currency::USDT()),
6138 LiquiditySide::Taker,
6139 report.client_order_id,
6140 None,
6141 UnixNanos::from(1),
6142 UnixNanos::from(1),
6143 None,
6144 );
6145 let failing_client = CommissionStubClient::new(CommissionOutcome::Failure);
6146 let mut fill_queue = ReconciliationFillQueue::default();
6147
6148 let first_events = manager.reconcile_order_with_fills(
6149 true,
6150 &order,
6151 &report,
6152 &[&explicit_fill],
6153 Some(&instrument),
6154 &mut fill_queue,
6155 Some(&failing_client),
6156 );
6157 let mut working = order;
6158 for event in &first_events {
6159 working
6160 .apply(event.clone())
6161 .expect("explicit fill projects cleanly");
6162 }
6163
6164 assert_eq!(first_events.len(), 1);
6165
6166 let OrderEventAny::Filled(explicit) = &first_events[0] else {
6167 panic!("expected the valid explicit fill");
6168 };
6169
6170 assert_eq!(explicit.last_qty, Quantity::from("4.0"));
6171 assert_eq!(
6172 explicit.commission,
6173 Some(Money::new(0.25, Currency::USDT()))
6174 );
6175 assert_eq!(working.status(), OrderStatus::PartiallyFilled);
6176
6177 let expected = Money::new(1.5, Currency::USDT());
6178 let retry_client = CommissionStubClient::new(CommissionOutcome::Value(expected));
6179 let mut reported_residual = explicit_fill.clone();
6180 reported_residual.trade_id = TradeId::from("T-COMMISSION-RESIDUAL");
6181 reported_residual.last_qty = residual_qty;
6182 reported_residual.last_px = residual_px;
6183 reported_residual.commission = expected;
6184
6185 let residual_reports = if status == OrderStatus::Filled {
6186 Vec::new()
6187 } else {
6188 vec![&reported_residual]
6189 };
6190
6191 let retry_events = manager.reconcile_order_with_fills(
6192 true,
6193 &working,
6194 &report,
6195 &residual_reports,
6196 Some(&instrument),
6197 &mut fill_queue,
6198 Some(&retry_client),
6199 );
6200
6201 assert_eq!(retry_events.len(), event_count);
6202
6203 let OrderEventAny::Filled(residual) = &retry_events[0] else {
6204 panic!("expected the residual fill");
6205 };
6206
6207 assert_eq!(residual.last_qty, residual_qty);
6208 assert_eq!(residual.last_px, residual_px);
6209 assert_eq!(residual.commission, Some(expected));
6210 assert_eq!(
6211 retry_client.seen(),
6212 (status == OrderStatus::Filled).then_some((
6213 residual_qty,
6214 residual.last_px,
6215 residual.liquidity_side
6216 )),
6217 "commission must use the exact price and liquidity carried by the residual fill"
6218 );
6219
6220 for event in &retry_events {
6221 working
6222 .apply(event.clone())
6223 .expect("residual precedes terminal status");
6224 }
6225
6226 retry_client.clear_seen();
6227 let replay = manager.reconcile_order_with_fills(
6228 true,
6229 &working,
6230 &report,
6231 &[],
6232 Some(&instrument),
6233 &mut fill_queue,
6234 Some(&retry_client),
6235 );
6236
6237 assert_eq!(working.status(), status);
6238 assert_eq!(working.filled_qty(), filled_qty);
6239 assert_eq!(
6240 working.commissions().get(&Currency::USDT()),
6241 Some(&Money::from("1.75 USDT"))
6242 );
6243 assert!(replay.is_empty());
6244 assert_eq!(retry_client.seen(), None);
6245 }
6246
6247 #[rstest]
6248 fn test_cached_reconciliation_preserves_explicit_fill_side() {
6249 let (mut manager, _cache, order, mut report, instrument) = cached_commission_fixtures();
6250 report.order_status = OrderStatus::PartiallyFilled;
6251 report.filled_qty = Quantity::from("4.0");
6252 let trade_id = TradeId::from("T-CONFLICTING-SIDE");
6253
6254 let explicit_fill = FillReport::new(
6255 report.account_id,
6256 report.instrument_id,
6257 report.venue_order_id,
6258 trade_id,
6259 OrderSide::Sell,
6260 Quantity::from("4.0"),
6261 Price::from("100.0"),
6262 Money::new(0.25, Currency::USDT()),
6263 LiquiditySide::Taker,
6264 report.client_order_id,
6265 None,
6266 UnixNanos::from(1),
6267 UnixNanos::from(1),
6268 None,
6269 );
6270 let mut fill_queue = ReconciliationFillQueue::default();
6271
6272 let events = manager.reconcile_order_with_fills(
6273 true,
6274 &order,
6275 &report,
6276 &[&explicit_fill],
6277 Some(&instrument),
6278 &mut fill_queue,
6279 None,
6280 );
6281
6282 assert_eq!(events.len(), 1);
6283
6284 let OrderEventAny::Filled(fill) = &events[0] else {
6285 panic!("expected the explicit fill");
6286 };
6287
6288 assert_eq!(fill.trade_id, trade_id);
6289 assert_eq!(fill.order_side, OrderSide::Sell);
6290 assert_eq!(fill.last_qty, Quantity::from("4.0"));
6291 assert_eq!(fill.last_px, Price::from("100.0"));
6292 }
6293
6294 #[rstest]
6295 fn test_continuous_report_preserves_newer_fills() {
6296 let (mut manager, _cache, mut order, mut report, instrument) = cached_commission_fixtures();
6297 let fill = TestOrderEventStubs::filled(
6298 &order,
6299 &instrument,
6300 Some(TradeId::from("T-NEWER-STREAM")),
6301 None,
6302 Some(Price::from("100.00")),
6303 Some(Quantity::from("2.0")),
6304 Some(LiquiditySide::Maker),
6305 None,
6306 None,
6307 Some(AccountId::from("TEST-001")),
6308 );
6309 order.apply(fill).unwrap();
6310 report.order_status = OrderStatus::PartiallyFilled;
6311 report.filled_qty = Quantity::from("1.0");
6312 let mut fill_queue = ReconciliationFillQueue::default();
6313
6314 let events = manager.reconcile_order_with_fills(
6315 false,
6316 &order,
6317 &report,
6318 &[],
6319 Some(&instrument),
6320 &mut fill_queue,
6321 None,
6322 );
6323
6324 assert!(events.is_empty());
6325 assert!(fill_queue.pending_fill_keys.is_empty());
6326 }
6327
6328 #[rstest]
6329 #[case::with_fills(true)]
6330 #[case::without_fills(false)]
6331 fn test_cached_snapshot_without_instrument_defers_unaccounted_fills(#[case] has_fills: bool) {
6332 let (mut manager, _cache, order, mut report, _instrument) = cached_commission_fixtures();
6333 report.order_status = OrderStatus::Canceled;
6334
6335 let explicit_fill = FillReport::new(
6336 report.account_id,
6337 report.instrument_id,
6338 report.venue_order_id,
6339 TradeId::from("T-MISSING-INSTRUMENT"),
6340 OrderSide::Buy,
6341 Quantity::from("4.0"),
6342 Price::from("100.0"),
6343 Money::new(0.25, Currency::USDT()),
6344 LiquiditySide::Taker,
6345 report.client_order_id,
6346 None,
6347 UnixNanos::from(1),
6348 UnixNanos::from(1),
6349 None,
6350 );
6351 let mut fill_queue = ReconciliationFillQueue::default();
6352
6353 let fills = if has_fills {
6354 vec![&explicit_fill]
6355 } else {
6356 Vec::new()
6357 };
6358
6359 let events = manager.reconcile_order_with_fills(
6360 true,
6361 &order,
6362 &report,
6363 &fills,
6364 None,
6365 &mut fill_queue,
6366 None,
6367 );
6368
6369 assert!(events.is_empty());
6370 assert_eq!(order.status(), OrderStatus::Accepted);
6371 assert_eq!(order.filled_qty(), Quantity::from("0.0"));
6372 assert!(fill_queue.pending_fill_keys.is_empty());
6373 }
6374
6375 #[rstest]
6376 #[case::canceled(OrderStatus::Canceled)]
6377 #[case::expired(OrderStatus::Expired)]
6378 fn test_terminal_order_report_does_not_void_cached_fills(#[case] status: OrderStatus) {
6379 let (manager, _cache, mut order, mut report, instrument) = cached_commission_fixtures();
6380 let fill = create_inferred_fill_for_qty(
6381 &order,
6382 &report,
6383 &report.account_id,
6384 &instrument,
6385 Quantity::from("4.0"),
6386 UnixNanos::from(1),
6387 None,
6388 )
6389 .unwrap();
6390 order.apply(fill).unwrap();
6391 report.order_status = status;
6392 report.filled_qty = Quantity::from("2.0");
6393 let client = CommissionStubClient::new(CommissionOutcome::Failure);
6394
6395 let events = manager
6396 .reconcile_order_report(&order, &report, Some(&instrument), Some(&client))
6397 .unwrap();
6398
6399 for event in &events {
6400 order.apply(event.clone()).unwrap();
6401 }
6402
6403 assert_eq!(events.len(), 1);
6404 assert_eq!(order.status(), status);
6405 assert_eq!(order.filled_qty(), Quantity::from("4.0"));
6406 assert_eq!(client.seen(), None);
6407 }
6408
6409 #[rstest]
6410 fn test_filled_order_ignores_superseded_cancel_report() {
6411 let (manager, cache, order, mut report, instrument) = cached_commission_fixtures();
6412 let venue_order_id = VenueOrderId::from("V-REPLACEMENT");
6413 let updated = OrderUpdatedSpec::builder()
6414 .trader_id(order.trader_id())
6415 .strategy_id(order.strategy_id())
6416 .instrument_id(order.instrument_id())
6417 .client_order_id(order.client_order_id())
6418 .account_id(report.account_id)
6419 .venue_order_id(venue_order_id)
6420 .quantity(order.quantity())
6421 .build();
6422 let order = cache
6423 .borrow_mut()
6424 .update_order(&OrderEventAny::Updated(updated))
6425 .unwrap();
6426 let mut fill_report = report.clone();
6427 fill_report.venue_order_id = venue_order_id;
6428 let commission = Money::from("1.25 USDT");
6429 let fill = create_inferred_fill_for_qty(
6430 &order,
6431 &fill_report,
6432 &report.account_id,
6433 &instrument,
6434 Quantity::from("10.0"),
6435 UnixNanos::from(2),
6436 Some(commission),
6437 )
6438 .unwrap();
6439 let order = cache.borrow_mut().update_order(&fill).unwrap();
6440 report.order_status = OrderStatus::Canceled;
6441 report.filled_qty = Quantity::from("0.0");
6442 report.avg_px = None;
6443 let client = CommissionStubClient::new(CommissionOutcome::Failure);
6444
6445 let events = manager
6446 .reconcile_order_report(&order, &report, Some(&instrument), Some(&client))
6447 .unwrap();
6448
6449 assert!(events.is_empty());
6450 assert_eq!(order.status(), OrderStatus::Filled);
6451 assert_eq!(order.venue_order_id(), Some(venue_order_id));
6452 assert_eq!(order.filled_qty(), Quantity::from("10.0"));
6453 assert_eq!(order.avg_px(), Some(dec!(100.0)));
6454 assert_eq!(
6455 order.commissions().get(&Currency::USDT()),
6456 Some(&commission)
6457 );
6458 assert_eq!(client.seen(), None);
6459 }
6460
6461 #[rstest]
6462 fn test_continuous_reconciliation_uses_source_client_and_retries_commission() {
6463 let (mut manager, _cache, order, report, _instrument) = cached_commission_fixtures();
6464 let client_id = ClientId::from("STUB");
6465
6466 let check = OpenOrderReportCheck {
6467 command: GenerateOrderStatusReports::new(
6468 UUID4::new(),
6469 UnixNanos::from(1),
6470 true,
6471 None,
6472 None,
6473 None,
6474 None,
6475 None,
6476 ),
6477 filtered_orders: vec![order],
6478 client_coverage: IndexMap::from([(
6479 report.client_order_id.unwrap(),
6480 ReportClientCoverage::Resolved(IndexSet::from([client_id])),
6481 )]),
6482 };
6483
6484 let queried_clients = IndexSet::from([client_id]);
6485 let failed_clients = IndexSet::new();
6486 let failing_client = CommissionStubClient::new(CommissionOutcome::Failure);
6487
6488 let failed = manager.reconcile_open_order_reports(
6489 &check,
6490 vec![SourcedOrderStatusReport {
6491 client_id,
6492 report: report.clone(),
6493 }],
6494 &queried_clients,
6495 &failed_clients,
6496 &[&failing_client],
6497 );
6498
6499 assert!(failed.events.is_empty());
6500
6501 let expected = Money::new(1.5, Currency::USDT());
6502 let retry_client = CommissionStubClient::new(CommissionOutcome::Value(expected));
6503 let retry = manager.reconcile_open_order_reports(
6504 &check,
6505 vec![SourcedOrderStatusReport { client_id, report }],
6506 &queried_clients,
6507 &failed_clients,
6508 &[&retry_client],
6509 );
6510
6511 assert_eq!(retry.events.len(), 1);
6512
6513 let OrderEventAny::Filled(fill) = &retry.events[0] else {
6514 panic!("expected inferred fill on valid retry");
6515 };
6516
6517 assert_eq!(fill.last_qty, Quantity::from("10.0"));
6518 assert_eq!(fill.commission, Some(expected));
6519 }
6520
6521 #[rstest]
6522 fn test_open_check_lookback_exclusion_warns_once_without_reconciliation_actions() {
6523 let client_order_id = ClientOrderId::from("O-LOOKBACK-OLD");
6524 let venue_order_id = VenueOrderId::from("V-LOOKBACK-OLD");
6525 let client_id = ClientId::from("BINANCE");
6526 let instrument_id = crypto_perpetual_ethusdt().id();
6527 let clock = Rc::new(RefCell::new(VirtualClock::new()));
6528 let cache = Rc::new(RefCell::new(Cache::default()));
6529 insert_accepted_limit_order(
6530 &cache,
6531 client_order_id,
6532 venue_order_id,
6533 instrument_id,
6534 client_id,
6535 );
6536 let order = cache.borrow().order_owned(&client_order_id).unwrap();
6537 let cutoff = order.ts_last().saturating_add(DurationNanos::new(1));
6538
6539 let check = OpenOrderReportCheck {
6540 command: GenerateOrderStatusReports::new(
6541 UUID4::new(),
6542 UnixNanos::from(1),
6543 false,
6544 None,
6545 Some(cutoff),
6546 None,
6547 None,
6548 None,
6549 ),
6550 filtered_orders: vec![order],
6551 client_coverage: IndexMap::from([(
6552 client_order_id,
6553 ReportClientCoverage::Resolved(IndexSet::from([client_id])),
6554 )]),
6555 };
6556
6557 let queried_clients = IndexSet::from([client_id]);
6558
6559 let mut manager = ExecutionManager::new(
6560 clock,
6561 cache.clone(),
6562 ExecutionManagerConfig {
6563 open_check_open_only: false,
6564 ..Default::default()
6565 },
6566 )
6567 .expect("valid config");
6568
6569 for _ in 0..2 {
6570 let result = manager.reconcile_open_order_reports(
6571 &check,
6572 Vec::new(),
6573 &queried_clients,
6574 &IndexSet::new(),
6575 &[],
6576 );
6577
6578 assert!(result.events.is_empty());
6579 assert!(result.targeted_queries.is_empty());
6580 assert_eq!(
6581 cache.borrow().order(&client_order_id).unwrap().status(),
6582 OrderStatus::Accepted
6583 );
6584 assert!(!manager.order_recon_retries.contains_key(&client_order_id));
6585 assert!(!manager.order_query_recency.contains_key(&client_order_id));
6586 assert!(!manager.order_query_pending.contains(&client_order_id));
6587 assert_eq!(
6588 manager.order_lookback_warnings,
6589 IndexSet::from([client_order_id])
6590 );
6591 assert_eq!(manager.order_lookback_warnings.len(), 1);
6592 }
6593 }
6594
6595 #[rstest]
6596 fn test_open_check_lookback_warning_clears_at_boundary_and_rearms() {
6597 let client_order_id = ClientOrderId::from("O-LOOKBACK-REARM");
6598 let client_id = ClientId::from("BINANCE");
6599 let cache = Rc::new(RefCell::new(Cache::default()));
6600 insert_accepted_limit_order(
6601 &cache,
6602 client_order_id,
6603 VenueOrderId::from("V-LOOKBACK-REARM"),
6604 crypto_perpetual_ethusdt().id(),
6605 client_id,
6606 );
6607 let order = cache.borrow().order_owned(&client_order_id).unwrap();
6608 let old_cutoff = order.ts_last().saturating_add(DurationNanos::new(1));
6609
6610 let make_check = |start| OpenOrderReportCheck {
6611 command: GenerateOrderStatusReports::new(
6612 UUID4::new(),
6613 UnixNanos::from(1),
6614 false,
6615 None,
6616 Some(start),
6617 None,
6618 None,
6619 None,
6620 ),
6621 filtered_orders: vec![order.clone()],
6622 client_coverage: IndexMap::from([(
6623 client_order_id,
6624 ReportClientCoverage::Resolved(IndexSet::from([client_id])),
6625 )]),
6626 };
6627
6628 let queried_clients = IndexSet::new();
6629
6630 let mut manager = ExecutionManager::new(
6631 Rc::new(RefCell::new(VirtualClock::new())),
6632 cache,
6633 ExecutionManagerConfig {
6634 open_check_open_only: false,
6635 ..Default::default()
6636 },
6637 )
6638 .expect("valid config");
6639
6640 manager.reconcile_open_order_reports(
6641 &make_check(old_cutoff),
6642 Vec::new(),
6643 &queried_clients,
6644 &IndexSet::new(),
6645 &[],
6646 );
6647 assert!(manager.order_lookback_warnings.contains(&client_order_id));
6648
6649 let boundary = order.ts_last();
6650 let boundary_result = manager.reconcile_open_order_reports(
6651 &make_check(boundary),
6652 Vec::new(),
6653 &queried_clients,
6654 &IndexSet::new(),
6655 &[],
6656 );
6657 assert!(boundary_result.targeted_queries.is_empty());
6658 assert!(!manager.order_lookback_warnings.contains(&client_order_id));
6659 assert!(manager.order_coverage_warnings.contains(&client_order_id));
6660
6661 manager.reconcile_open_order_reports(
6662 &make_check(old_cutoff),
6663 Vec::new(),
6664 &queried_clients,
6665 &IndexSet::new(),
6666 &[],
6667 );
6668 assert_eq!(
6669 manager.order_lookback_warnings,
6670 IndexSet::from([client_order_id])
6671 );
6672 }
6673
6674 #[rstest]
6675 fn test_venue_order_id_mapped_report_clears_old_order_lookback_warning() {
6676 let client_order_id = ClientOrderId::from("O-LOOKBACK-MAPPED");
6677 let venue_order_id = VenueOrderId::from("V-LOOKBACK-MAPPED");
6678 let client_id = ClientId::from("BINANCE");
6679 let instrument_id = crypto_perpetual_ethusdt().id();
6680 let cache = Rc::new(RefCell::new(Cache::default()));
6681 insert_accepted_limit_order(
6682 &cache,
6683 client_order_id,
6684 venue_order_id,
6685 instrument_id,
6686 client_id,
6687 );
6688 let order = cache.borrow().order_owned(&client_order_id).unwrap();
6689 let cutoff = order.ts_last().saturating_add(DurationNanos::new(1));
6690
6691 let check = OpenOrderReportCheck {
6692 command: GenerateOrderStatusReports::new(
6693 UUID4::new(),
6694 UnixNanos::from(1),
6695 false,
6696 None,
6697 Some(cutoff),
6698 None,
6699 None,
6700 None,
6701 ),
6702 filtered_orders: vec![order],
6703 client_coverage: IndexMap::from([(
6704 client_order_id,
6705 ReportClientCoverage::Resolved(IndexSet::from([client_id])),
6706 )]),
6707 };
6708
6709 let mut manager = ExecutionManager::new(
6710 Rc::new(RefCell::new(VirtualClock::new())),
6711 cache,
6712 ExecutionManagerConfig {
6713 open_check_open_only: false,
6714 ..Default::default()
6715 },
6716 )
6717 .expect("valid config");
6718
6719 manager.order_lookback_warnings.insert(client_order_id);
6720
6721 let report = OrderStatusReport::new(
6724 AccountId::from("TEST-001"),
6725 instrument_id,
6726 None,
6727 venue_order_id,
6728 OrderSide::Buy.into(),
6729 OrderType::Limit,
6730 TimeInForce::Gtc,
6731 OrderStatus::Accepted,
6732 Quantity::from("10.0"),
6733 Quantity::from("0.0"),
6734 UnixNanos::from(0),
6735 UnixNanos::from(0),
6736 UnixNanos::from(0),
6737 None,
6738 );
6739
6740 let result = manager.reconcile_open_order_reports(
6741 &check,
6742 vec![SourcedOrderStatusReport { client_id, report }],
6743 &IndexSet::from([client_id]),
6744 &IndexSet::new(),
6745 &[],
6746 );
6747
6748 assert!(result.targeted_queries.is_empty());
6749 assert!(!manager.order_lookback_warnings.contains(&client_order_id));
6750 }
6751
6752 #[rstest]
6753 fn test_positive_report_clears_old_order_lookback_warning_without_reinserting_it() {
6754 let client_order_id = ClientOrderId::from("O-LOOKBACK-REPORTED");
6755 let venue_order_id = VenueOrderId::from("V-LOOKBACK-REPORTED");
6756 let client_id = ClientId::from("BINANCE");
6757 let instrument_id = crypto_perpetual_ethusdt().id();
6758 let cache = Rc::new(RefCell::new(Cache::default()));
6759 insert_accepted_limit_order(
6760 &cache,
6761 client_order_id,
6762 venue_order_id,
6763 instrument_id,
6764 client_id,
6765 );
6766 let order = cache.borrow().order_owned(&client_order_id).unwrap();
6767 let cutoff = order.ts_last().saturating_add(DurationNanos::new(1));
6768
6769 let check = OpenOrderReportCheck {
6770 command: GenerateOrderStatusReports::new(
6771 UUID4::new(),
6772 UnixNanos::from(1),
6773 false,
6774 None,
6775 Some(cutoff),
6776 None,
6777 None,
6778 None,
6779 ),
6780 filtered_orders: vec![order],
6781 client_coverage: IndexMap::from([(
6782 client_order_id,
6783 ReportClientCoverage::Resolved(IndexSet::from([client_id])),
6784 )]),
6785 };
6786
6787 let mut manager = ExecutionManager::new(
6788 Rc::new(RefCell::new(VirtualClock::new())),
6789 cache,
6790 ExecutionManagerConfig {
6791 open_check_open_only: false,
6792 ..Default::default()
6793 },
6794 )
6795 .expect("valid config");
6796
6797 manager.order_lookback_warnings.insert(client_order_id);
6798
6799 let report = OrderStatusReport::new(
6800 AccountId::from("TEST-001"),
6801 instrument_id,
6802 Some(client_order_id),
6803 venue_order_id,
6804 OrderSide::Buy.into(),
6805 OrderType::Limit,
6806 TimeInForce::Gtc,
6807 OrderStatus::Accepted,
6808 Quantity::from("10.0"),
6809 Quantity::from("0.0"),
6810 UnixNanos::from(0),
6811 UnixNanos::from(0),
6812 UnixNanos::from(0),
6813 None,
6814 );
6815
6816 let result = manager.reconcile_open_order_reports(
6817 &check,
6818 vec![SourcedOrderStatusReport { client_id, report }],
6819 &IndexSet::from([client_id]),
6820 &IndexSet::new(),
6821 &[],
6822 );
6823
6824 assert!(result.targeted_queries.is_empty());
6825 assert!(!manager.order_lookback_warnings.contains(&client_order_id));
6826 }
6827
6828 #[rstest]
6829 fn test_targeted_reconciliation_orders_interleaved_fills(
6830 #[values(false, true)] requires_authoritative_fills: bool,
6831 ) {
6832 let (mut manager, cache, opening, mut opening_report, instrument) =
6833 cached_commission_fixtures();
6834 let account_id = opening_report.account_id;
6835 let client_id = ClientId::from("STUB");
6836 let closing_id = ClientOrderId::from("O-CLOSING");
6837 let closing_venue_id = VenueOrderId::from("V-CLOSING");
6838 let closing = OrderTestBuilder::new(OrderType::Limit)
6839 .client_order_id(closing_id)
6840 .instrument_id(instrument.id())
6841 .side(OrderSide::Sell)
6842 .quantity(Quantity::from("10.0"))
6843 .price(Price::from("101.0"))
6844 .reduce_only(true)
6845 .build();
6846 let submitted = TestOrderEventStubs::submitted(&closing, account_id);
6847 cache
6848 .borrow_mut()
6849 .add_order(closing, None, Some(client_id), false)
6850 .unwrap();
6851 let closing = cache.borrow_mut().update_order(&submitted).unwrap();
6852 let accepted = TestOrderEventStubs::accepted(&closing, account_id, closing_venue_id);
6853 cache.borrow_mut().update_order(&accepted).unwrap();
6854 opening_report.avg_px = Some(dec!(99));
6855 opening_report.ts_last = UnixNanos::from(300);
6856 let mut closing_report = opening_report.clone();
6857 closing_report.client_order_id = Some(closing_id);
6858 closing_report.venue_order_id = closing_venue_id;
6859 closing_report.order_side = Some(OrderSide::Sell);
6860 closing_report.avg_px = Some(dec!(102));
6861 closing_report.ts_last = UnixNanos::from(400);
6862 let opening_id = opening.client_order_id();
6863
6864 let results = [
6865 (
6866 closing_report,
6867 [
6868 ("T-CLOSE-2", "103.0", "0.04 USDT", 400),
6869 ("T-CLOSE-1", "101.0", "0.02 USDT", 200),
6870 ],
6871 ),
6872 (
6873 opening_report,
6874 [
6875 ("T-OPEN-2", "100.0", "0.03 USDT", 300),
6876 ("T-OPEN-1", "98.0", "0.01 USDT", 100),
6877 ],
6878 ),
6879 ]
6880 .into_iter()
6881 .map(|(report, fills)| TargetedOrderReportResult {
6882 client_order_id: report.client_order_id.unwrap(),
6883 client_id: Some(client_id),
6884 fills: fills
6885 .into_iter()
6886 .map(|(trade_id, price, commission, timestamp)| {
6887 FillReport::new(
6888 account_id,
6889 instrument.id(),
6890 report.venue_order_id,
6891 TradeId::from(trade_id),
6892 report.order_side.unwrap(),
6893 Quantity::from("5.0"),
6894 Price::from(price),
6895 Money::from(commission),
6896 LiquiditySide::Taker,
6897 report.client_order_id,
6898 None,
6899 UnixNanos::from(timestamp),
6900 UnixNanos::from(timestamp + 1),
6901 None,
6902 )
6903 })
6904 .collect(),
6905 report: Some(report),
6906 coverage_complete: true,
6907 })
6908 .collect();
6909
6910 let mut client = CommissionStubClient::new(CommissionOutcome::Failure);
6911 client.requires_authoritative_fills = requires_authoritative_fills;
6912 let events = manager.reconcile_targeted_order_reports(results, &[&client]);
6913
6914 let fills = events
6915 .iter()
6916 .map(|event| {
6917 let OrderEventAny::Filled(fill) = event else {
6918 panic!("expected only authoritative fills");
6919 };
6920
6921 assert_eq!(fill.account_id, account_id);
6922 assert_eq!(fill.instrument_id, instrument.id());
6923 assert_eq!(fill.last_qty, Quantity::from("5.0"));
6924 assert_eq!(fill.liquidity_side, LiquiditySide::Taker);
6925 (
6926 fill.trade_id,
6927 fill.client_order_id,
6928 fill.order_side,
6929 fill.last_px,
6930 fill.commission,
6931 fill.ts_event,
6932 )
6933 })
6934 .collect::<Vec<_>>();
6935
6936 assert_eq!(client.seen(), None);
6937 assert_eq!(
6938 fills,
6939 vec![
6940 (
6941 TradeId::from("T-OPEN-1"),
6942 opening_id,
6943 OrderSide::Buy,
6944 Price::from("98.0"),
6945 Some(Money::from("0.01 USDT")),
6946 UnixNanos::from(100)
6947 ),
6948 (
6949 TradeId::from("T-CLOSE-1"),
6950 closing_id,
6951 OrderSide::Sell,
6952 Price::from("101.0"),
6953 Some(Money::from("0.02 USDT")),
6954 UnixNanos::from(200)
6955 ),
6956 (
6957 TradeId::from("T-OPEN-2"),
6958 opening_id,
6959 OrderSide::Buy,
6960 Price::from("100.0"),
6961 Some(Money::from("0.03 USDT")),
6962 UnixNanos::from(300)
6963 ),
6964 (
6965 TradeId::from("T-CLOSE-2"),
6966 closing_id,
6967 OrderSide::Sell,
6968 Price::from("103.0"),
6969 Some(Money::from("0.04 USDT")),
6970 UnixNanos::from(400)
6971 ),
6972 ],
6973 );
6974 }
6975
6976 #[rstest]
6977 fn test_targeted_reconciliation_uses_source_client_and_retries_commission() {
6978 let (mut manager, _cache, _order, report, _instrument) = cached_commission_fixtures();
6979 let client_order_id = report.client_order_id.unwrap();
6980 let client_id = ClientId::from("STUB");
6981 let failing_client = CommissionStubClient::new(CommissionOutcome::Failure);
6982
6983 let failed = manager.reconcile_targeted_order_reports(
6984 vec![TargetedOrderReportResult {
6985 client_order_id,
6986 client_id: Some(client_id),
6987 report: Some(report.clone()),
6988 fills: Vec::new(),
6989 coverage_complete: true,
6990 }],
6991 &[&failing_client],
6992 );
6993
6994 assert!(failed.is_empty());
6995
6996 let expected = Money::new(1.5, Currency::USDT());
6997 let retry_client = CommissionStubClient::new(CommissionOutcome::Value(expected));
6998 let retry = manager.reconcile_targeted_order_reports(
6999 vec![TargetedOrderReportResult {
7000 client_order_id,
7001 client_id: Some(client_id),
7002 report: Some(report),
7003 fills: Vec::new(),
7004 coverage_complete: true,
7005 }],
7006 &[&retry_client],
7007 );
7008
7009 assert_eq!(retry.len(), 1);
7010
7011 let OrderEventAny::Filled(fill) = &retry[0] else {
7012 panic!("expected inferred fill on valid targeted retry");
7013 };
7014
7015 assert_eq!(fill.last_qty, Quantity::from("10.0"));
7016 assert_eq!(fill.commission, Some(expected));
7017 }
7018
7019 #[rstest]
7020 fn test_clear_recon_tracking_removes_targeted_query() {
7021 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7022 let cache = Rc::new(RefCell::new(Cache::default()));
7023 let mut manager = ExecutionManager::new(clock, cache, ExecutionManagerConfig::default())
7024 .expect("valid config");
7025 let client_order_id = ClientOrderId::from("O-TARGETED-CLEAR");
7026 manager.order_query_pending.insert(client_order_id);
7027 manager.order_lookback_warnings.insert(client_order_id);
7028
7029 manager.clear_recon_tracking(&client_order_id, true);
7030
7031 assert!(manager.order_query_pending.is_empty());
7032 assert!(manager.order_lookback_warnings.is_empty());
7033 }
7034
7035 #[rstest]
7036 fn test_submission_confirmation_skips_untracked_order_cache(
7037 #[values(false, true)] previously_registered: bool,
7038 ) {
7039 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7040 let cache = Rc::new(RefCell::new(Cache::default()));
7041
7042 let mut manager = ExecutionManager::new(
7043 clock,
7044 cache.clone(),
7045 ExecutionManagerConfig {
7046 submission_recovery_policy: SubmissionRecoveryPolicy::RetainUnresolved,
7047 ..Default::default()
7048 },
7049 )
7050 .expect("valid config");
7051
7052 let order = OrderTestBuilder::new(OrderType::Limit)
7053 .instrument_id(InstrumentId::from("ETHUSDT.BYBIT"))
7054 .quantity(Quantity::from("10.0"))
7055 .price(Price::from("100.0"))
7056 .build();
7057 let client_order_id = order.client_order_id();
7058 let account_id = AccountId::from("TEST-001");
7059 let submitted = TestOrderEventStubs::submitted(&order, account_id);
7060 if previously_registered {
7061 manager.register_submission(order.init_event(), None);
7062 }
7063
7064 cache
7065 .borrow_mut()
7066 .add_order(order, None, None, false)
7067 .unwrap();
7068 let order = cache.borrow_mut().update_order(&submitted).unwrap();
7069 let accepted =
7070 TestOrderEventStubs::accepted(&order, account_id, VenueOrderId::from("V-UNTRACKED"));
7071 cache.borrow_mut().update_order(&accepted).unwrap();
7072
7073 if previously_registered {
7074 manager.confirm_submission_outcome(&client_order_id);
7075 }
7076
7077 assert!(!manager.submissions.contains_key(&client_order_id));
7078 assert!(!manager.order_inflight_checks.contains_key(&client_order_id));
7079
7080 let cached = cache.borrow_mut();
7082 manager.confirm_submission_outcome(&client_order_id);
7083
7084 assert_eq!(
7085 cached.order(&client_order_id).unwrap().status(),
7086 OrderStatus::Accepted,
7087 );
7088 }
7089
7090 #[rstest]
7091 #[case(false)]
7092 #[case(true)]
7093 fn test_denial_resolves_only_matching_inflight_commands(#[case] reverse: bool) {
7094 let client_order_id = ClientOrderId::from("O-DENIAL-TRACKING");
7095 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7096 let cache = Rc::new(RefCell::new(Cache::default()));
7097 let mut manager =
7098 ExecutionManager::new(clock, cache, ExecutionManagerConfig::default()).unwrap();
7099 let first = UUID4::new();
7100 let second = UUID4::new();
7101 manager.register_inflight(client_order_id, first);
7102 manager.register_inflight(client_order_id, second);
7103 let (resolved, remaining) = if reverse {
7104 (second, first)
7105 } else {
7106 (first, second)
7107 };
7108
7109 for cause in [None, Some(UUID4::new()), Some(resolved), Some(resolved)] {
7110 let event = OrderEventAny::ModifyDenied(
7111 OrderModifyDeniedSpec::builder()
7112 .client_order_id(client_order_id)
7113 .maybe_causation_id(cause)
7114 .build(),
7115 );
7116 manager.observe_order_event(&event);
7117 assert!(manager.order_inflight_checks.contains_key(&client_order_id));
7118 }
7119
7120 let event = OrderEventAny::CancelDenied(
7121 OrderCancelDeniedSpec::builder()
7122 .client_order_id(client_order_id)
7123 .causation_id(remaining)
7124 .build(),
7125 );
7126 manager.observe_order_event(&event);
7127 assert!(!manager.order_inflight_checks.contains_key(&client_order_id));
7128 }
7129
7130 #[rstest]
7131 fn test_register_inflight_skips_filtered_order() {
7132 let client_order_id = ClientOrderId::from("O-FILTERED-REGISTER");
7133 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7134 let cache = Rc::new(RefCell::new(Cache::default()));
7135
7136 let mut manager = ExecutionManager::new(
7137 clock,
7138 cache,
7139 ExecutionManagerConfig {
7140 filtered_client_order_ids: IndexSet::from([client_order_id]),
7141 ..Default::default()
7142 },
7143 )
7144 .expect("valid config");
7145
7146 manager.register_inflight(client_order_id, UUID4::new());
7147
7148 assert!(!manager.order_inflight_checks.contains_key(&client_order_id));
7149 assert!(!manager.order_recon_retries.contains_key(&client_order_id));
7150 }
7151
7152 #[rstest]
7153 #[cfg_attr(
7154 not(all(feature = "simulation", madsim)),
7155 tokio::test(start_paused = true)
7156 )]
7157 #[cfg_attr(all(feature = "simulation", madsim), madsim::test)]
7158 async fn test_inflight_check_retires_order_filtered_after_registration() {
7159 let client_order_id = ClientOrderId::from("O-FILTERED-LATE");
7160 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7161 let cache = Rc::new(RefCell::new(Cache::default()));
7162
7163 let mut manager = ExecutionManager::new(
7164 clock,
7165 cache,
7166 ExecutionManagerConfig {
7167 inflight_threshold_ms: 100,
7168 ..Default::default()
7169 },
7170 )
7171 .expect("valid config");
7172
7173 manager.register_inflight(client_order_id, UUID4::new());
7174 manager
7175 .config
7176 .filtered_client_order_ids
7177 .insert(client_order_id);
7178 dst::time::sleep(Duration::from_millis(101)).await;
7179
7180 let first = manager.check_inflight_orders();
7181
7182 assert!(first.events.is_empty());
7183 assert!(first.queries.is_empty());
7184 assert!(!manager.order_inflight_checks.contains_key(&client_order_id));
7185 assert!(!manager.order_recon_retries.contains_key(&client_order_id));
7186
7187 dst::time::sleep(Duration::from_millis(101)).await;
7188 let second = manager.check_inflight_orders();
7189 assert!(second.events.is_empty());
7190 assert!(second.queries.is_empty());
7191 assert!(!manager.order_inflight_checks.contains_key(&client_order_id));
7192 }
7193
7194 #[rstest]
7195 #[case(false, OrderStatus::PendingUpdate, true, true, true)]
7196 #[case(false, OrderStatus::Accepted, false, true, true)]
7197 #[case(false, OrderStatus::Canceled, false, true, false)]
7198 #[case(true, OrderStatus::PendingCancel, true, true, true)]
7199 #[case(true, OrderStatus::Accepted, false, true, true)]
7200 #[case(true, OrderStatus::Filled, false, true, false)]
7201 fn test_observe_order_status_report_tracking_matrix(
7202 #[case] with_fills: bool,
7203 #[case] status: OrderStatus,
7204 #[case] expect_inflight: bool,
7205 #[case] expect_activity: bool,
7206 #[case] expect_last_query: bool,
7207 ) {
7208 let client_order_id = ClientOrderId::from("O-STATUS-MATRIX");
7209 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7210 let cache = Rc::new(RefCell::new(Cache::default()));
7211 let mut manager = ExecutionManager::new(clock, cache, ExecutionManagerConfig::default())
7212 .expect("valid config");
7213 manager.register_inflight(client_order_id, UUID4::new());
7214 manager.order_query_recency.mark(client_order_id);
7215 manager.order_coverage_warnings.insert(client_order_id);
7216 manager.order_coverage_unresolved.insert(client_order_id);
7217 manager.order_query_pending.insert(client_order_id);
7218
7219 let order_report = OrderStatusReport::new(
7220 AccountId::from("TEST-001"),
7221 crypto_perpetual_ethusdt().id(),
7222 Some(client_order_id),
7223 VenueOrderId::from("V-STATUS-MATRIX"),
7224 OrderSide::Buy.into(),
7225 OrderType::Limit,
7226 TimeInForce::Gtc,
7227 status,
7228 Quantity::from("10.0"),
7229 Quantity::from("0.0"),
7230 UnixNanos::from(1_000),
7231 UnixNanos::from(1_000),
7232 UnixNanos::from(1_000),
7233 None,
7234 );
7235
7236 let report = if with_fills {
7237 ExecutionReport::OrderWithFills(Box::new(order_report), Vec::new())
7238 } else {
7239 ExecutionReport::Order(Box::new(order_report))
7240 };
7241
7242 manager.observe_execution_report(&report);
7243
7244 assert_eq!(
7245 manager.order_inflight_checks.contains_key(&client_order_id),
7246 expect_inflight,
7247 );
7248 assert_eq!(
7249 manager.order_recon_retries.contains_key(&client_order_id),
7250 expect_inflight,
7251 );
7252 assert_eq!(
7253 manager.order_activity.contains_key(&client_order_id),
7254 expect_activity,
7255 );
7256 assert_eq!(
7257 manager.order_query_recency.contains_key(&client_order_id),
7258 expect_last_query,
7259 );
7260 assert_eq!(
7261 manager.order_coverage_warnings.contains(&client_order_id),
7262 expect_inflight,
7263 );
7264 assert_eq!(
7265 manager.order_coverage_unresolved.contains(&client_order_id),
7266 expect_inflight,
7267 );
7268 assert_eq!(
7269 manager.order_query_pending.contains(&client_order_id),
7270 expect_inflight,
7271 );
7272 }
7273
7274 #[rstest]
7275 #[case(OrderStatus::PendingUpdate)]
7276 #[case(OrderStatus::PendingCancel)]
7277 fn test_accepted_report_during_pending_command_preserves_inflight_tracking(
7278 #[case] pending_status: OrderStatus,
7279 ) {
7280 let client_order_id = ClientOrderId::from("O-PENDING-COMMAND");
7281 let venue_order_id = VenueOrderId::from("V-PENDING-COMMAND");
7282 let account_id = AccountId::from("TEST-001");
7283 let client_id = ClientId::from("TEST");
7284 let instrument_id = crypto_perpetual_ethusdt().id();
7285 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7286 let cache = Rc::new(RefCell::new(Cache::default()));
7287 insert_accepted_limit_order(
7288 &cache,
7289 client_order_id,
7290 venue_order_id,
7291 instrument_id,
7292 client_id,
7293 );
7294
7295 let order = cache.borrow().order_owned(&client_order_id).unwrap();
7296
7297 let event = match pending_status {
7298 OrderStatus::PendingUpdate => OrderEventAny::PendingUpdate(
7299 OrderPendingUpdateSpec::builder()
7300 .trader_id(order.trader_id())
7301 .strategy_id(order.strategy_id())
7302 .instrument_id(instrument_id)
7303 .client_order_id(client_order_id)
7304 .account_id(account_id)
7305 .venue_order_id(venue_order_id)
7306 .build(),
7307 ),
7308 OrderStatus::PendingCancel => OrderEventAny::PendingCancel(
7309 OrderPendingCancelSpec::builder()
7310 .trader_id(order.trader_id())
7311 .strategy_id(order.strategy_id())
7312 .instrument_id(instrument_id)
7313 .client_order_id(client_order_id)
7314 .account_id(account_id)
7315 .venue_order_id(venue_order_id)
7316 .build(),
7317 ),
7318 _ => unreachable!(),
7319 };
7320
7321 cache.borrow_mut().update_order(&event).unwrap();
7322
7323 let mut manager =
7324 ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
7325 .expect("valid config");
7326 manager.register_inflight(client_order_id, UUID4::new());
7327 manager.order_query_recency.mark(client_order_id);
7328 manager.order_coverage_warnings.insert(client_order_id);
7329 manager.order_coverage_unresolved.insert(client_order_id);
7330 manager.order_query_pending.insert(client_order_id);
7331 let report = OrderStatusReport::new(
7332 account_id,
7333 instrument_id,
7334 Some(client_order_id),
7335 venue_order_id,
7336 OrderSide::Buy.into(),
7337 OrderType::Limit,
7338 TimeInForce::Gtc,
7339 OrderStatus::Accepted,
7340 Quantity::from("10.0"),
7341 Quantity::from("0.0"),
7342 UnixNanos::from(1_000),
7343 UnixNanos::from(1_000),
7344 UnixNanos::from(1_000),
7345 None,
7346 )
7347 .with_price(Price::from("100.0"));
7348
7349 manager.observe_execution_report(&ExecutionReport::Order(Box::new(report.clone())));
7350 let order = cache.borrow().order_owned(&client_order_id).unwrap();
7351 let events =
7352 generate_reconciliation_order_events(&order, &report, None, UnixNanos::from(1_000));
7353
7354 assert!(events.is_empty());
7355 assert_eq!(order.status(), pending_status);
7356 assert!(manager.order_inflight_checks.contains_key(&client_order_id));
7357 assert!(manager.order_recon_retries.contains_key(&client_order_id));
7358 assert!(manager.order_query_recency.contains_key(&client_order_id));
7359 assert!(manager.order_activity.contains_key(&client_order_id));
7360 assert!(manager.order_coverage_warnings.contains(&client_order_id));
7361 assert!(manager.order_coverage_unresolved.contains(&client_order_id));
7362 assert!(manager.order_query_pending.contains(&client_order_id));
7363 }
7364
7365 #[rstest]
7366 fn test_superseded_cancel_report_preserves_missing_order_grace() {
7367 let client_order_id = ClientOrderId::from("O-CANCEL-REPLACE");
7368 let old_venue_order_id = VenueOrderId::from("V-CANCEL-REPLACE-OLD");
7369 let new_venue_order_id = VenueOrderId::from("V-CANCEL-REPLACE-NEW");
7370 let account_id = AccountId::from("TEST-001");
7371 let client_id = ClientId::from("TEST");
7372 let instrument_id = crypto_perpetual_ethusdt().id();
7373 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7374 let cache = Rc::new(RefCell::new(Cache::default()));
7375 insert_accepted_limit_order(
7376 &cache,
7377 client_order_id,
7378 old_venue_order_id,
7379 instrument_id,
7380 client_id,
7381 );
7382
7383 let order = cache.borrow().order_owned(&client_order_id).unwrap();
7384 let pending_update = OrderPendingUpdateSpec::builder()
7385 .trader_id(order.trader_id())
7386 .strategy_id(order.strategy_id())
7387 .instrument_id(order.instrument_id())
7388 .client_order_id(client_order_id)
7389 .account_id(account_id)
7390 .venue_order_id(old_venue_order_id)
7391 .build();
7392 cache
7393 .borrow_mut()
7394 .update_order(&OrderEventAny::PendingUpdate(pending_update))
7395 .unwrap();
7396 let order = cache.borrow().order_owned(&client_order_id).unwrap();
7397 let updated = OrderUpdatedSpec::builder()
7398 .trader_id(order.trader_id())
7399 .strategy_id(order.strategy_id())
7400 .instrument_id(order.instrument_id())
7401 .client_order_id(client_order_id)
7402 .quantity(order.quantity())
7403 .venue_order_id(new_venue_order_id)
7404 .account_id(account_id)
7405 .build();
7406 cache
7407 .borrow_mut()
7408 .update_order(&OrderEventAny::Updated(updated))
7409 .unwrap();
7410
7411 let mut manager = ExecutionManager::new(
7412 clock,
7413 cache.clone(),
7414 ExecutionManagerConfig {
7415 open_check_missing_retries: 1,
7416 ..Default::default()
7417 },
7418 )
7419 .expect("valid config");
7420
7421 manager.record_local_activity(client_order_id);
7422 assert!(
7423 manager
7424 .prepare_missing_order_query(client_order_id)
7425 .is_none()
7426 );
7427
7428 let report = OrderStatusReport::new(
7429 account_id,
7430 instrument_id,
7431 Some(client_order_id),
7432 old_venue_order_id,
7433 OrderSide::Buy.into(),
7434 OrderType::Limit,
7435 TimeInForce::Gtc,
7436 OrderStatus::Canceled,
7437 Quantity::from("10.0"),
7438 Quantity::from("0.0"),
7439 UnixNanos::from(1_000),
7440 UnixNanos::from(2_000),
7441 UnixNanos::from(3_000),
7442 None,
7443 );
7444
7445 manager.observe_execution_report(&ExecutionReport::Order(Box::new(report.clone())));
7446 let order = cache.borrow().order_owned(&client_order_id).unwrap();
7447 let events =
7448 generate_reconciliation_order_events(&order, &report, None, UnixNanos::from(1_000));
7449
7450 assert!(events.is_empty());
7451 assert_eq!(order.status(), OrderStatus::Accepted);
7452 assert_eq!(order.venue_order_id(), Some(new_venue_order_id));
7453 assert!(manager.order_activity.contains_key(&client_order_id));
7454 assert!(
7455 manager
7456 .prepare_missing_order_query(client_order_id)
7457 .is_none()
7458 );
7459 assert_eq!(manager.recon_check_retry_count(&client_order_id), 0);
7460 }
7461
7462 #[rstest]
7463 #[cfg_attr(
7464 not(all(feature = "simulation", madsim)),
7465 tokio::test(start_paused = true)
7466 )]
7467 #[cfg_attr(all(feature = "simulation", madsim), madsim::test)]
7468 async fn test_prune_order_local_activity_uses_open_check_threshold() {
7469 let old_id = ClientOrderId::from("O-ACTIVITY-OLD");
7470 let fresh_id = ClientOrderId::from("O-ACTIVITY-FRESH");
7471 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7472 let cache = Rc::new(RefCell::new(Cache::default()));
7473
7474 let mut manager = ExecutionManager::new(
7475 clock,
7476 cache,
7477 ExecutionManagerConfig {
7478 open_check_threshold_ns: DurationNanos::from_millis(100),
7479 ..Default::default()
7480 },
7481 )
7482 .expect("valid config");
7483
7484 manager.record_local_activity(old_id);
7485 dst::time::sleep(Duration::from_millis(101)).await;
7486 manager.record_local_activity(fresh_id);
7487
7488 manager.prune_order_local_activity();
7489
7490 assert!(!manager.order_activity.contains_key(&old_id));
7491 assert!(manager.order_activity.contains_key(&fresh_id));
7492 }
7493
7494 #[rstest]
7495 #[cfg_attr(
7496 not(all(feature = "simulation", madsim)),
7497 tokio::test(start_paused = true)
7498 )]
7499 #[cfg_attr(all(feature = "simulation", madsim), madsim::test)]
7500 async fn test_unapplied_fill_report_expires_after_position_check_threshold() {
7501 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7502 let cache = Rc::new(RefCell::new(Cache::default()));
7503
7504 let mut manager = ExecutionManager::new(
7505 clock,
7506 cache,
7507 ExecutionManagerConfig {
7508 position_check_threshold_ns: DurationNanos::from_millis(100),
7509 ..Default::default()
7510 },
7511 )
7512 .expect("valid config");
7513
7514 let report = unapplied_fill_report("T-UNAPPLIED");
7515 let mut expired = vec![manager.is_unapplied_fill_report_expired(&report)];
7516
7517 manager.record_unapplied_fill_report(&report);
7518 dst::time::sleep(Duration::from_millis(60)).await;
7519 manager.record_unapplied_fill_report(&report);
7520 expired.push(manager.is_unapplied_fill_report_expired(&report));
7521 dst::time::sleep(Duration::from_millis(40)).await;
7522 expired.push(manager.is_unapplied_fill_report_expired(&report));
7523
7524 assert_eq!(expired, vec![false, false, true]);
7525 }
7526
7527 #[rstest]
7528 #[cfg_attr(
7529 not(all(feature = "simulation", madsim)),
7530 tokio::test(start_paused = true)
7531 )]
7532 #[cfg_attr(all(feature = "simulation", madsim), madsim::test)]
7533 async fn test_record_unapplied_fill_report_prunes_outside_position_check_lookback() {
7534 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7535 let cache = Rc::new(RefCell::new(Cache::default()));
7536
7537 let mut manager = ExecutionManager::new(
7538 clock,
7539 cache,
7540 ExecutionManagerConfig {
7541 position_check_lookback_mins: 1,
7542 position_check_threshold_ns: DurationNanos::from_secs(5),
7543 ..Default::default()
7544 },
7545 )
7546 .expect("valid config");
7547
7548 let old_report = unapplied_fill_report("T-UNAPPLIED-OLD");
7549 let recent_report = unapplied_fill_report("T-UNAPPLIED-RECENT");
7550 let fresh_report = unapplied_fill_report("T-UNAPPLIED-FRESH");
7551
7552 manager.record_unapplied_fill_report(&old_report);
7553 dst::time::sleep(Duration::from_secs(30)).await;
7554 manager.record_unapplied_fill_report(&recent_report);
7555 dst::time::sleep(Duration::from_secs(31)).await;
7556 manager.record_unapplied_fill_report(&fresh_report);
7557
7558 assert!(!manager.fills_unapplied.contains_key(&(
7559 old_report.account_id,
7560 old_report.instrument_id,
7561 old_report.trade_id,
7562 )));
7563 assert!(manager.fills_unapplied.contains_key(&(
7564 recent_report.account_id,
7565 recent_report.instrument_id,
7566 recent_report.trade_id,
7567 )));
7568 assert!(manager.fills_unapplied.contains_key(&(
7569 fresh_report.account_id,
7570 fresh_report.instrument_id,
7571 fresh_report.trade_id,
7572 )));
7573 }
7574
7575 fn unapplied_fill_report(trade_id: &str) -> FillReport {
7576 FillReport::new(
7577 AccountId::from("SIM-001"),
7578 InstrumentId::from("ETHUSDT-PERP.BINANCE"),
7579 VenueOrderId::from("V-UNAPPLIED"),
7580 TradeId::from(trade_id),
7581 OrderSide::Buy,
7582 Quantity::from("1.0"),
7583 Price::from("100.0"),
7584 Money::from("0.10 USDT"),
7585 LiquiditySide::Taker,
7586 None,
7587 None,
7588 UnixNanos::from(1),
7589 UnixNanos::from(1),
7590 None,
7591 )
7592 }
7593
7594 #[rstest]
7595 fn test_prepare_open_order_report_check_builds_bulk_command_with_config() {
7596 let lookback_mins = 5_u64;
7597 let lookback = DurationNanos::from_mins(lookback_mins);
7598 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7599 let cache = Rc::new(RefCell::new(Cache::default()));
7600
7601 let mut manager = ExecutionManager::new(
7602 clock.clone(),
7603 cache.clone(),
7604 ExecutionManagerConfig {
7605 open_check_lookback_mins: Some(lookback_mins),
7606 open_check_open_only: false,
7607 reconciliation_instrument_ids: IndexSet::from([crypto_perpetual_ethusdt().id()]),
7608 ..Default::default()
7609 },
7610 )
7611 .expect("valid config");
7612
7613 let included_id = ClientOrderId::from("O-REPORT-001");
7614 let excluded_id = ClientOrderId::from("O-REPORT-002");
7615 let included_instrument_id = crypto_perpetual_ethusdt().id();
7616 let excluded_instrument_id = btcusd_bybit().id();
7617
7618 cache
7619 .borrow_mut()
7620 .add_instrument(InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt()))
7621 .unwrap();
7622 cache
7623 .borrow_mut()
7624 .add_instrument(InstrumentAny::CryptoPerpetual(btcusd_bybit()))
7625 .unwrap();
7626 insert_accepted_limit_order(
7627 &cache,
7628 included_id,
7629 VenueOrderId::from("V-REPORT-001"),
7630 included_instrument_id,
7631 ClientId::from("BINANCE"),
7632 );
7633 insert_accepted_limit_order(
7634 &cache,
7635 excluded_id,
7636 VenueOrderId::from("V-REPORT-002"),
7637 excluded_instrument_id,
7638 ClientId::from("BYBIT"),
7639 );
7640 clock
7641 .borrow_mut()
7642 .advance_time(UnixNanos::default().saturating_add(lookback * 2), true);
7643
7644 let ts_now = clock.borrow().timestamp_ns();
7645 let command_id = UUID4::new();
7646 let check = manager.prepare_open_order_report_check(command_id, &[]);
7647
7648 assert_eq!(check.command.command_id, command_id);
7649 assert_eq!(check.command.ts_init, ts_now);
7650 assert!(!check.command.open_only);
7651 assert_eq!(check.command.instrument_id, None);
7652 assert_eq!(check.command.start, Some(ts_now.saturating_sub(lookback)));
7653 assert_eq!(check.command.end, None);
7654 assert_eq!(check.command.log_receipt_level, LogLevel::Debug);
7655 assert_eq!(check.filtered_orders.len(), 1);
7656 assert_eq!(check.filtered_orders[0].client_order_id(), included_id);
7657 }
7658
7659 #[rstest]
7660 fn test_prepare_position_report_check_builds_bulk_command_with_coverage() {
7661 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7662 let cache = Rc::new(RefCell::new(Cache::default()));
7663
7664 let manager = ExecutionManager::new(
7665 clock.clone(),
7666 cache.clone(),
7667 ExecutionManagerConfig {
7668 reconciliation_instrument_ids: IndexSet::from([crypto_perpetual_ethusdt().id()]),
7669 ..Default::default()
7670 },
7671 )
7672 .expect("valid config");
7673
7674 let included_instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
7675 let excluded_instrument = InstrumentAny::CryptoPerpetual(btcusd_bybit());
7676
7677 cache
7678 .borrow_mut()
7679 .add_instrument(included_instrument.clone())
7680 .unwrap();
7681 cache
7682 .borrow_mut()
7683 .add_instrument(excluded_instrument.clone())
7684 .unwrap();
7685 let included_position = insert_open_position(
7686 &cache,
7687 &included_instrument,
7688 PositionId::from("P-REPORT-001"),
7689 OrderSide::Buy,
7690 "5.0",
7691 "3000.00",
7692 );
7693 insert_open_position(
7694 &cache,
7695 &excluded_instrument,
7696 PositionId::from("P-REPORT-002"),
7697 OrderSide::Buy,
7698 "2.0",
7699 "40000.00",
7700 );
7701
7702 let ts_now = clock.borrow().timestamp_ns();
7703 let command_id = UUID4::new();
7704 let check = manager.prepare_position_report_check(command_id, &[]);
7705 let key = (
7706 included_position.instrument_id,
7707 included_position.account_id,
7708 );
7709
7710 assert_eq!(check.command.command_id, command_id);
7711 assert_eq!(check.command.ts_init, ts_now);
7712 assert_eq!(check.command.instrument_id, None);
7713 assert_eq!(check.command.start, None);
7714 assert_eq!(check.command.end, None);
7715 assert_eq!(check.command.log_receipt_level, LogLevel::Debug);
7716 assert_eq!(check.client_coverage.len(), 1);
7717 assert_eq!(
7718 check.client_coverage.get(&key),
7719 Some(&ReportClientCoverage::Unresolved)
7720 );
7721 assert_eq!(check.activity_revisions.get(&key), Some(&0));
7722 }
7723
7724 #[rstest]
7725 #[case::unresolved(ReportClientCoverage::Unresolved)]
7726 #[case::empty(ReportClientCoverage::Resolved(IndexSet::new()))]
7727 #[case::unqueried(ReportClientCoverage::Resolved(IndexSet::from([ClientId::from("BYBIT")])))]
7728 fn test_position_reconciliation_preserves_position_without_client_coverage(
7729 #[case] coverage: ReportClientCoverage,
7730 ) {
7731 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7732 let cache = Rc::new(RefCell::new(Cache::default()));
7733
7734 let mut manager = ExecutionManager::new(
7735 clock,
7736 cache.clone(),
7737 ExecutionManagerConfig {
7738 position_check_threshold_ns: DurationNanos::ZERO,
7739 ..Default::default()
7740 },
7741 )
7742 .expect("valid config");
7743
7744 let instrument = test_bybit_spot_instrument();
7745 cache
7746 .borrow_mut()
7747 .add_instrument(instrument.clone())
7748 .unwrap();
7749 let position = insert_open_position(
7750 &cache,
7751 &instrument,
7752 PositionId::from("P-COVERAGE-PRESERVED"),
7753 OrderSide::Buy,
7754 "5.0",
7755 "3000.00",
7756 );
7757 let key = (position.instrument_id, position.account_id);
7758 let mut check = manager.prepare_position_report_check(UUID4::new(), &[]);
7759 check.client_coverage.insert(key, coverage);
7760 manager.set_position_reconciliation_retries(key, PositionReportShape::Unambiguous, 1);
7761
7762 let events = manager.reconcile_position_reports(
7763 &check,
7764 Vec::new(),
7765 &IndexSet::new(),
7766 &IndexSet::new(),
7767 );
7768
7769 assert!(events.is_empty());
7770 assert_eq!(manager.position_recon_retry_count(&key), 1);
7771 }
7772
7773 #[rstest]
7774 fn test_position_reconciliation_preserves_unavailable_spot_coverage() {
7775 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7776 let cache = Rc::new(RefCell::new(Cache::default()));
7777 let mut manager =
7778 ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
7779 .expect("valid config");
7780 let derivative = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
7781 let spot = test_bybit_spot_instrument();
7782 cache
7783 .borrow_mut()
7784 .add_instrument(derivative.clone())
7785 .unwrap();
7786 cache.borrow_mut().add_instrument(spot.clone()).unwrap();
7787 let derivative_position = insert_open_position(
7788 &cache,
7789 &derivative,
7790 PositionId::from("P-DERIVATIVE-RECONCILE"),
7791 OrderSide::Buy,
7792 "5.0",
7793 "3000.00",
7794 );
7795 let spot_position = insert_open_position(
7796 &cache,
7797 &spot,
7798 PositionId::from("P-SPOT-PRESERVED"),
7799 OrderSide::Buy,
7800 "2.0",
7801 "2000.00",
7802 );
7803 let client = PositionCoverageStubClient;
7804 let check = manager.prepare_position_report_check(UUID4::new(), &[&client]);
7805 let queried_clients = IndexSet::from([client.client_id()]);
7806
7807 let events = manager.reconcile_position_reports(
7808 &check,
7809 Vec::new(),
7810 &queried_clients,
7811 &IndexSet::new(),
7812 );
7813
7814 assert!(events.iter().any(|event| {
7815 matches!(event, OrderEventAny::Filled(fill) if fill.instrument_id == derivative_position.instrument_id)
7816 }));
7817 assert!(!events.iter().any(|event| {
7818 matches!(event, OrderEventAny::Filled(fill) if fill.instrument_id == spot_position.instrument_id)
7819 }));
7820 }
7821
7822 #[rstest]
7823 fn test_position_reconciliation_preserves_spot_position_when_client_query_fails() {
7824 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7825 let cache = Rc::new(RefCell::new(Cache::default()));
7826 let mut manager =
7827 ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
7828 .expect("valid config");
7829 let instrument = test_bybit_spot_instrument();
7830 cache
7831 .borrow_mut()
7832 .add_instrument(instrument.clone())
7833 .unwrap();
7834 let position = insert_open_position(
7835 &cache,
7836 &instrument,
7837 PositionId::from("P-SPOT-QUERY-FAILED"),
7838 OrderSide::Buy,
7839 "5.0",
7840 "3000.00",
7841 );
7842 let key = (position.instrument_id, position.account_id);
7843 let client_id = ClientId::from("BYBIT");
7844 let mut check = manager.prepare_position_report_check(UUID4::new(), &[]);
7845 check.client_coverage.insert(
7846 key,
7847 ReportClientCoverage::Resolved(IndexSet::from([client_id])),
7848 );
7849 let queried_clients = IndexSet::from([client_id]);
7850 let failed_clients = IndexSet::from([client_id]);
7851
7852 let events = manager.reconcile_position_reports(
7853 &check,
7854 Vec::new(),
7855 &queried_clients,
7856 &failed_clients,
7857 );
7858
7859 assert!(
7860 !events
7861 .iter()
7862 .any(|event| matches!(event, OrderEventAny::Filled(_))),
7863 "a failed bulk query must not generate a synthetic closing fill",
7864 );
7865 let cached_position = cache.borrow().position(&position.id).unwrap().clone();
7866 assert!(cached_position.is_open());
7867 assert_eq!(cached_position.quantity, Quantity::from("5.0"));
7868 }
7869
7870 #[rstest]
7871 #[cfg_attr(
7872 not(all(feature = "simulation", madsim)),
7873 tokio::test(start_paused = true)
7874 )]
7875 #[cfg_attr(all(feature = "simulation", madsim), madsim::test)]
7876 async fn test_position_report_check_defers_activity_recorded_during_delayed_request() {
7877 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7878 let cache = Rc::new(RefCell::new(Cache::default()));
7879
7880 let mut manager = ExecutionManager::new(
7881 clock,
7882 cache.clone(),
7883 ExecutionManagerConfig {
7884 position_check_threshold_ns: DurationNanos::from_secs(5),
7885 ..Default::default()
7886 },
7887 )
7888 .expect("valid config");
7889
7890 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
7891 let instrument_id = instrument.id();
7892 let position = insert_open_position(
7893 &cache,
7894 &instrument,
7895 PositionId::from("P-ACTIVITY-DURING-REQUEST"),
7896 OrderSide::Buy,
7897 "5.0",
7898 "3000.00",
7899 );
7900 cache
7901 .borrow_mut()
7902 .add_instrument(instrument.clone())
7903 .unwrap();
7904 let account_id = position.account_id;
7905 let check = manager.prepare_position_report_check(UUID4::new(), &[]);
7906
7907 let report = PositionStatusReport::new(
7908 account_id,
7909 instrument_id,
7910 PositionSide::Long,
7911 Quantity::from("5.0"),
7912 UnixNanos::from(1_000_000),
7913 UnixNanos::from(1_000_000),
7914 None,
7915 None,
7916 Some(Decimal::from(3000)),
7917 );
7918
7919 let closed_position = close_long_position(
7920 position,
7921 &instrument,
7922 TradeId::from("T-ACTIVITY-DURING-REQUEST"),
7923 );
7924 cache
7925 .borrow_mut()
7926 .update_position(&closed_position)
7927 .unwrap();
7928 manager.record_position_activity(instrument_id, account_id);
7929
7930 dst::time::sleep(Duration::from_secs(6)).await;
7932
7933 let events = manager.reconcile_position_reports(
7934 &check,
7935 vec![report],
7936 &IndexSet::new(),
7937 &IndexSet::new(),
7938 );
7939
7940 assert!(
7941 !events.iter().any(|event| {
7942 matches!(
7943 event,
7944 OrderEventAny::Filled(fill)
7945 if fill.order_side == OrderSide::Buy
7946 && fill.last_qty == Quantity::from("5.0")
7947 )
7948 }),
7949 "activity recorded after the request started must defer A's stale report",
7950 );
7951 }
7952
7953 #[rstest]
7954 fn test_position_report_check_does_not_defer_activity_recorded_before_request() {
7955 let clock = Rc::new(RefCell::new(VirtualClock::new()));
7956 let cache = Rc::new(RefCell::new(Cache::default()));
7957
7958 let mut manager = ExecutionManager::new(
7959 clock,
7960 cache.clone(),
7961 ExecutionManagerConfig {
7962 position_check_threshold_ns: DurationNanos::ZERO,
7963 ..Default::default()
7964 },
7965 )
7966 .expect("valid config");
7967
7968 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
7969 let instrument_id = instrument.id();
7970 let position = insert_open_position(
7971 &cache,
7972 &instrument,
7973 PositionId::from("P-ACTIVITY-BEFORE-REQUEST"),
7974 OrderSide::Buy,
7975 "5.0",
7976 "3000.00",
7977 );
7978 cache.borrow_mut().add_instrument(instrument).unwrap();
7979 let account_id = position.account_id;
7980 manager.record_position_activity(instrument_id, account_id);
7981 let check = manager.prepare_position_report_check(UUID4::new(), &[]);
7982
7983 let report = PositionStatusReport::new(
7984 account_id,
7985 instrument_id,
7986 PositionSide::Long,
7987 Quantity::from("10.0"),
7988 UnixNanos::from(1_000_000),
7989 UnixNanos::from(1_000_000),
7990 None,
7991 None,
7992 Some(Decimal::from(3000)),
7993 );
7994
7995 let events = manager.reconcile_position_reports(
7996 &check,
7997 vec![report],
7998 &IndexSet::new(),
7999 &IndexSet::new(),
8000 );
8001
8002 let fills: Vec<_> = events
8003 .iter()
8004 .filter_map(|event| match event {
8005 OrderEventAny::Filled(fill) => Some(fill),
8006 _ => None,
8007 })
8008 .collect();
8009
8010 assert_eq!(fills.len(), 1);
8011 assert_eq!(fills[0].order_side, OrderSide::Buy);
8012 assert_eq!(fills[0].last_qty, Quantity::from("5.0"));
8013 assert_eq!(fills[0].commission, None);
8014 }
8015
8016 #[rstest]
8017 fn test_mass_status_projects_companion_fill_before_void_correction() {
8018 let clock = Rc::new(RefCell::new(VirtualClock::new()));
8019 let cache = Rc::new(RefCell::new(Cache::default()));
8020 let mut manager =
8021 ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
8022 .expect("valid config");
8023 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
8024 let client_order_id = ClientOrderId::from("O-MASS-VOID-001");
8025 let venue_order_id = VenueOrderId::from("V-MASS-VOID-001");
8026 let account_id = AccountId::from("TEST-001");
8027 cache
8028 .borrow_mut()
8029 .add_instrument(instrument.clone())
8030 .unwrap();
8031 insert_accepted_limit_order(
8032 &cache,
8033 client_order_id,
8034 venue_order_id,
8035 instrument.id(),
8036 ClientId::from("BINANCE"),
8037 );
8038 let order = cache.borrow().order_owned(&client_order_id).unwrap();
8039 let initial_fill = TestOrderEventStubs::filled(
8040 &order,
8041 &instrument,
8042 Some(TradeId::from("T-MASS-VOID-INITIAL")),
8043 None,
8044 Some(Price::from("100.0")),
8045 Some(Quantity::from("6.0")),
8046 Some(LiquiditySide::Taker),
8047 None,
8048 None,
8049 Some(account_id),
8050 );
8051 cache.borrow_mut().update_order(&initial_fill).unwrap();
8052 let order = cache.borrow().order_owned(&client_order_id).unwrap();
8053
8054 let report = OrderStatusReport::new(
8055 account_id,
8056 instrument.id(),
8057 Some(client_order_id),
8058 venue_order_id,
8059 OrderSide::Buy.into(),
8060 OrderType::Limit,
8061 TimeInForce::Gtc,
8062 OrderStatus::Canceled,
8063 Quantity::from("10.0"),
8064 Quantity::from("5.0"),
8065 UnixNanos::from(1_000),
8066 UnixNanos::from(1_000),
8067 UnixNanos::from(1_000),
8068 None,
8069 );
8070
8071 let companion_fill = FillReport::new(
8072 account_id,
8073 instrument.id(),
8074 venue_order_id,
8075 TradeId::from("T-MASS-VOID-COMPANION"),
8076 OrderSide::Buy,
8077 Quantity::from("1.0"),
8078 Price::from("100.0"),
8079 Money::zero(instrument.quote_currency()),
8080 LiquiditySide::Taker,
8081 Some(client_order_id),
8082 None,
8083 UnixNanos::from(900),
8084 UnixNanos::from(1_000),
8085 None,
8086 );
8087
8088 let mut fill_queue = ReconciliationFillQueue::default();
8089 let events = manager.reconcile_order_with_fills(
8090 true,
8091 &order,
8092 &report,
8093 &[&companion_fill],
8094 Some(&instrument),
8095 &mut fill_queue,
8096 None,
8097 );
8098 let mut projected = order;
8099 for event in &events {
8100 projected.apply(event.clone()).unwrap();
8101 }
8102
8103 assert!(matches!(events[0], OrderEventAny::Filled(_)));
8104 assert_eq!(
8105 events
8106 .iter()
8107 .filter(|event| matches!(event, OrderEventAny::FillVoided(_)))
8108 .count(),
8109 2
8110 );
8111 assert_eq!(projected.status(), OrderStatus::Canceled);
8112 assert_eq!(projected.filled_qty(), Quantity::from("5.0"));
8113 assert_eq!(projected.voided_qty(), Quantity::from("2.0"));
8114 }
8115
8116 fn insert_accepted_limit_order(
8117 cache: &Rc<RefCell<Cache>>,
8118 client_order_id: ClientOrderId,
8119 venue_order_id: VenueOrderId,
8120 instrument_id: InstrumentId,
8121 client_id: ClientId,
8122 ) {
8123 let account_id = AccountId::from("TEST-001");
8124 let order = OrderTestBuilder::new(OrderType::Limit)
8125 .client_order_id(client_order_id)
8126 .instrument_id(instrument_id)
8127 .quantity(Quantity::from("10.0"))
8128 .price(Price::from("100.0"))
8129 .build();
8130 let submitted = TestOrderEventStubs::submitted(&order, account_id);
8131 cache
8132 .borrow_mut()
8133 .add_order(order, None, Some(client_id), false)
8134 .unwrap();
8135 let order = cache.borrow_mut().update_order(&submitted).unwrap();
8136 let accepted = TestOrderEventStubs::accepted(&order, account_id, venue_order_id);
8137 cache.borrow_mut().update_order(&accepted).unwrap();
8138 }
8139
8140 fn test_bybit_spot_instrument() -> InstrumentAny {
8141 InstrumentAny::CurrencyPair(
8142 CurrencyPair::builder()
8143 .instrument_id(InstrumentId::from("ETHUSDT-SPOT.BYBIT"))
8144 .raw_symbol(Symbol::from("ETHUSDT"))
8145 .base_currency(Currency::from("ETH"))
8146 .quote_currency(Currency::from("USDT"))
8147 .price_precision(2)
8148 .size_precision(5)
8149 .price_increment(Price::from("0.01"))
8150 .size_increment(Quantity::from("0.00001"))
8151 .ts_event(UnixNanos::default())
8152 .ts_init(UnixNanos::default())
8153 .build()
8154 .unwrap(),
8155 )
8156 }
8157
8158 fn insert_open_position(
8159 cache: &Rc<RefCell<Cache>>,
8160 instrument: &InstrumentAny,
8161 position_id: PositionId,
8162 side: OrderSide,
8163 quantity: &str,
8164 price: &str,
8165 ) -> Position {
8166 let order = OrderTestBuilder::new(OrderType::Market)
8167 .instrument_id(instrument.id())
8168 .side(side)
8169 .quantity(Quantity::from(quantity))
8170 .build();
8171 let fill = TestOrderEventStubs::filled(
8172 &order,
8173 instrument,
8174 Some(TradeId::new("T-REPORT-001")),
8175 Some(position_id),
8176 Some(Price::from(price)),
8177 Some(Quantity::from(quantity)),
8178 None,
8179 None,
8180 None,
8181 Some(AccountId::from("TEST-001")),
8182 );
8183 let order_filled: OrderFilled = fill.into();
8184 let position = Position::new(instrument, order_filled);
8185 cache
8186 .borrow_mut()
8187 .add_position(&position, OmsType::Hedging)
8188 .unwrap();
8189 position
8190 }
8191
8192 fn close_long_position(
8193 mut position: Position,
8194 instrument: &InstrumentAny,
8195 trade_id: TradeId,
8196 ) -> Position {
8197 let order = OrderTestBuilder::new(OrderType::Market)
8198 .instrument_id(instrument.id())
8199 .side(OrderSide::Sell)
8200 .quantity(position.quantity)
8201 .build();
8202 let fill = TestOrderEventStubs::filled(
8203 &order,
8204 instrument,
8205 Some(trade_id),
8206 Some(position.id),
8207 Some(Price::from("3000.00")),
8208 Some(position.quantity),
8209 None,
8210 None,
8211 None,
8212 Some(position.account_id),
8213 );
8214 let order_filled: OrderFilled = fill.into();
8215 position.apply(&order_filled);
8216 position
8217 }
8218
8219 #[cfg(feature = "node")]
8220 mod node {
8221 use nautilus_model::events::order::spec::OrderFillVoidedSpec;
8222
8223 use super::*;
8224 use crate::execution::client::LiveExecutionClient;
8225
8226 #[rstest]
8227 fn test_position_fill_reports_contained_prefix_matches_full_report(
8228 #[values(
8229 "account",
8230 "instrument",
8231 "venue_order",
8232 "client_order",
8233 "trade",
8234 "position",
8235 "side",
8236 "price",
8237 "liquidity",
8238 "quantity",
8239 "commission",
8240 "currency"
8241 )]
8242 field: &str,
8243 ) {
8244 let (manager, _, report) = position_history_fixture();
8245 let mut changed = report.clone();
8246 match field {
8247 "account" => changed.account_id = AccountId::from("OTHER-002"),
8248 "instrument" => changed.instrument_id = InstrumentId::from("OTHER.SIM"),
8249 "venue_order" => changed.venue_order_id = VenueOrderId::from("V-OTHER"),
8250 "client_order" => changed.client_order_id = Some(ClientOrderId::from("O-OTHER")),
8251 "trade" => changed.trade_id = TradeId::from("T-OTHER"),
8252 "position" => changed.venue_position_id = Some(PositionId::from("P-OTHER")),
8253 "side" => changed.order_side = OrderSide::Sell,
8254 "price" => changed.last_px = Price::from("3101.00"),
8255 "liquidity" => changed.liquidity_side = LiquiditySide::Maker,
8256 "quantity" => changed.last_qty = Quantity::from("3.000"),
8257 "commission" => changed.commission = Money::from("0.17 USDT"),
8258 "currency" => changed.commission = Money::from("0.13 USD"),
8259 _ => unreachable!(),
8260 }
8261
8262 let reports = [report.clone(), changed, report.clone()];
8263 let scalar: Vec<_> = reports
8264 .iter()
8265 .map(|report| manager.position_contains_fill_report(report))
8266 .collect();
8267 let prefix = manager.position_fill_reports_contained_prefix(&reports);
8268 let repeated =
8269 manager.position_fill_reports_contained_prefix(&[report.clone(), report]);
8270
8271 assert_eq!(scalar, vec![true, false, true]);
8272 assert_eq!(prefix, 1);
8273 assert_eq!(repeated, 2);
8274 assert_eq!(manager.position_fill_reports_contained_prefix(&[]), 0);
8275 }
8276
8277 #[rstest]
8278 fn test_position_fill_reports_contained_prefix_indexes_only_routed_positions(
8279 #[values(false, true)] closed: bool,
8280 #[values(false, true)] missing: bool,
8281 ) {
8282 let (manager, cache, mut report) = position_history_fixture();
8283 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
8284 let position = insert_open_position(
8285 &cache,
8286 &instrument,
8287 PositionId::from("P-UNRELATED"),
8288 OrderSide::Buy,
8289 "4.000",
8290 "3101.00",
8291 );
8292
8293 if closed {
8294 let position =
8295 close_long_position(position, &instrument, TradeId::from("T-UNRELATED-CLOSE"));
8296 cache.borrow_mut().update_position(&position).unwrap();
8297 }
8298
8299 let trade_id = report.trade_id;
8300 if missing {
8301 report.trade_id = TradeId::from("T-MISSING");
8302 }
8303
8304 let prefix =
8305 manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8306 let cache = cache.borrow();
8307 let positions = cache.positions_refs(
8308 None,
8309 Some(&report.instrument_id),
8310 None,
8311 Some(&report.account_id),
8312 None,
8313 );
8314 let mut replay = IndexMap::new();
8315 let contained = position_fill_report_matches(
8316 &cache,
8317 &report,
8318 &positions,
8319 |id| cache.hedging_flip_position_ids(id),
8320 Some(&mut replay),
8321 );
8322
8323 assert_eq!(positions.len(), 2);
8324 assert_eq!(contained, !missing);
8325 assert_eq!(prefix, if missing { 0 } else { 2 });
8326 assert_eq!(
8327 replay,
8328 IndexMap::from([(
8329 report.venue_position_id.unwrap(),
8330 IndexMap::from([(trade_id, vec![0])]),
8331 )]),
8332 );
8333 }
8334
8335 #[rstest]
8336 fn test_position_fill_reports_contained_prefix_resolves_client_order() {
8337 let (manager, cache, mut report) = position_history_fixture();
8338 let position_id = report.venue_position_id.unwrap();
8339 cache
8340 .borrow_mut()
8341 .add_venue_order_id(
8342 &report.client_order_id.unwrap(),
8343 &report.venue_order_id,
8344 false,
8345 )
8346 .unwrap();
8347 report.client_order_id = None;
8348 let before =
8349 manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8350 {
8351 let mut cache = cache.borrow_mut();
8352 let mut position = cache.position_mut(&position_id).unwrap();
8353
8354 let PositionReplayEvent::Filled(fill) = &mut position.replay_events[0] else {
8355 unreachable!()
8356 };
8357
8358 fill.client_order_id = ClientOrderId::from("O-OTHER");
8359 }
8360
8361 let after = manager.position_fill_reports_contained_prefix(&[report.clone(), report]);
8362
8363 assert_eq!(before, 2);
8364 assert_eq!(after, 0);
8365 }
8366
8367 #[rstest]
8368 fn test_position_fill_reports_contained_prefix_retains_reordered_fragments(
8369 #[values(false, true)] reverse: bool,
8370 ) {
8371 let (manager, cache, mut report) = position_history_fixture();
8372 let position_id = report.venue_position_id.unwrap();
8373 {
8374 let mut cache = cache.borrow_mut();
8375 let mut position = cache.position_mut(&position_id).unwrap();
8376
8377 let PositionReplayEvent::Filled(mut fragment) = position.replay_events[0].clone()
8378 else {
8379 unreachable!()
8380 };
8381
8382 fragment.last_qty = Quantity::from("3.000");
8383 fragment.commission = Some(Money::from("0.29 USDT"));
8384 let mut unrelated = fragment.clone();
8385 unrelated.trade_id = TradeId::from("T-UNRELATED");
8386 position
8387 .replay_events
8388 .push(PositionReplayEvent::Filled(unrelated));
8389 position
8390 .replay_events
8391 .push(PositionReplayEvent::Filled(fragment));
8392
8393 if reverse {
8394 position.replay_events.reverse();
8395 }
8396 }
8397
8398 let original =
8399 manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8400 report.last_qty = Quantity::from("5.000");
8401 report.commission = Money::from("0.42 USDT");
8402 let combined =
8403 manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8404 let scalar = manager.position_contains_fill_report(&report);
8405
8406 assert_eq!(original, 0);
8407 assert_eq!(combined, 2);
8408 assert!(scalar);
8409 }
8410
8411 #[rstest]
8412 fn test_position_fill_reports_contained_prefix_rechecks_after_applied_fill() {
8413 let (manager, cache, first) = position_history_fixture();
8414 let position_id = first.venue_position_id.unwrap();
8415 let mut second = first.clone();
8416 second.trade_id = TradeId::from("T-NEXT");
8417 second.last_qty = Quantity::from("1.500");
8418 second.last_px = Price::from("3110.00");
8419 second.commission = Money::from("0.29 USDT");
8420 let reports = [first, second.clone()];
8421 let before = manager.position_fill_reports_contained_prefix(&reports);
8422 {
8423 let mut cache = cache.borrow_mut();
8424 let mut position = cache.position_mut(&position_id).unwrap();
8425
8426 let PositionReplayEvent::Filled(mut fill) = position.replay_events[0].clone()
8427 else {
8428 unreachable!()
8429 };
8430
8431 fill.trade_id = second.trade_id;
8432 fill.last_qty = second.last_qty;
8433 fill.last_px = second.last_px;
8434 fill.commission = Some(second.commission);
8435 fill.event_id = UUID4::new();
8436 position.apply(&fill);
8437 }
8438
8439 let after = manager.position_fill_reports_contained_prefix(&reports);
8440 let cache = cache.borrow();
8441 let position = cache.position_ref(&position_id).unwrap();
8442
8443 assert_eq!(before, 1);
8444 assert_eq!(after, 2);
8445 assert_eq!(position.quantity, Quantity::from("3.500"));
8446 assert_eq!(position.commissions(), vec![Money::from("0.42 USDT")]);
8447 assert_eq!(position.replay_events.len(), 2);
8448 assert_eq!(
8449 manager.position_activity_revision(&(second.instrument_id, second.account_id)),
8450 0
8451 );
8452 }
8453
8454 #[rstest]
8455 fn test_position_fill_reports_contained_prefix_rebuilds_after_history_changes(
8456 #[values("missing_commission", "currency", "payload", "removal")] mutation: &str,
8457 ) {
8458 let (manager, cache, report) = position_history_fixture();
8459 let reports = [report.clone(), report.clone()];
8460 let before = manager.position_fill_reports_contained_prefix(&reports);
8461 let revision =
8462 manager.position_activity_revision(&(report.instrument_id, report.account_id));
8463 {
8464 let mut cache = cache.borrow_mut();
8465
8466 if mutation == "removal" {
8467 let position_id = report.venue_position_id.unwrap();
8468 {
8469 let mut position = cache.position_mut(&position_id).unwrap();
8470
8471 let PositionReplayEvent::Filled(mut closing) =
8472 position.replay_events[0].clone()
8473 else {
8474 unreachable!()
8475 };
8476
8477 closing.trade_id = TradeId::from("T-HISTORY-CLOSE");
8478 closing.order_side = OrderSide::Sell;
8479 closing.event_id = UUID4::new();
8480 position.apply(&closing);
8481 }
8482
8483 cache.purge_position(position_id, false).unwrap();
8484 } else {
8485 let mut position = cache
8486 .position_mut(&report.venue_position_id.unwrap())
8487 .unwrap();
8488
8489 let PositionReplayEvent::Filled(fill) = &mut position.replay_events[0] else {
8490 unreachable!()
8491 };
8492
8493 match mutation {
8494 "missing_commission" => fill.commission = None,
8495 "currency" => fill.commission = Some(Money::from("0.13 USD")),
8496 "payload" => fill.last_px = Price::from("3101.00"),
8497 _ => unreachable!(),
8498 }
8499 }
8500 }
8501
8502 let after = manager.position_fill_reports_contained_prefix(&reports);
8503 let revision_after =
8504 manager.position_activity_revision(&(report.instrument_id, report.account_id));
8505
8506 assert_eq!(before, 2);
8507 assert_eq!(after, 0);
8508 assert_eq!(revision, 0);
8509 assert_eq!(revision_after, 0);
8510 }
8511
8512 #[rstest]
8513 fn test_position_fill_reports_contained_prefix_preserves_virtual_flip_proof(
8514 #[values(
8515 "unchanged",
8516 "missing_source",
8517 "conflicting_fragment",
8518 "opening_void",
8519 "closing_void"
8520 )]
8521 change: &str,
8522 ) {
8523 let (manager, cache, first) = position_history_fixture();
8524 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
8525 let source_id = first.venue_position_id.unwrap();
8526 let destination_id = PositionId::from("P-HISTORY-DESTINATION");
8527 let mut order = OrderTestBuilder::new(OrderType::Market)
8528 .instrument_id(instrument.id())
8529 .client_order_id(ClientOrderId::from("O-HISTORY-FLIP"))
8530 .side(OrderSide::Sell)
8531 .quantity(Quantity::from("5.000"))
8532 .build();
8533 order
8534 .apply(TestOrderEventStubs::submitted(&order, first.account_id))
8535 .unwrap();
8536 order
8537 .apply(TestOrderEventStubs::accepted(
8538 &order,
8539 first.account_id,
8540 VenueOrderId::from("V-HISTORY-FLIP"),
8541 ))
8542 .unwrap();
8543 let event = TestOrderEventStubs::filled(
8544 &order,
8545 &instrument,
8546 Some(TradeId::from("T-HISTORY-FLIP")),
8547 Some(source_id),
8548 Some(Price::from("3100.00")),
8549 Some(Quantity::from("3.000")),
8550 Some(LiquiditySide::Taker),
8551 Some(Money::from("0.75 USDT")),
8552 None,
8553 Some(first.account_id),
8554 );
8555
8556 let OrderEventAny::Filled(fill) = event.clone() else {
8557 unreachable!()
8558 };
8559
8560 order.apply(event).unwrap();
8561 let (closing, opening) = fill
8562 .split_for_position_flip(
8563 Quantity::from("2.000"),
8564 Some(destination_id),
8565 UUID4::new(),
8566 )
8567 .unwrap();
8568 {
8569 let mut cache = cache.borrow_mut();
8570 cache.position_mut(&source_id).unwrap().apply(&closing);
8571 cache
8572 .add_order(order, Some(source_id), None, false)
8573 .unwrap();
8574 cache
8575 .add_position(&Position::new(&instrument, opening), OmsType::Hedging)
8576 .unwrap();
8577 }
8578
8579 let mut report = FillReport::new(
8580 fill.account_id,
8581 fill.instrument_id,
8582 fill.venue_order_id,
8583 fill.trade_id,
8584 fill.order_side,
8585 fill.last_qty,
8586 fill.last_px,
8587 fill.commission.unwrap(),
8588 fill.liquidity_side,
8589 Some(fill.client_order_id),
8590 Some(source_id),
8591 fill.ts_event,
8592 fill.ts_init,
8593 None,
8594 );
8595 let before =
8596 manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8597 {
8598 let mut cache = cache.borrow_mut();
8599
8600 match change {
8601 "unchanged" => {}
8602 "missing_source" => cache.purge_position(source_id, false).unwrap(),
8603 "conflicting_fragment" => {
8604 let mut position = cache.position_mut(&destination_id).unwrap();
8605
8606 let PositionReplayEvent::Filled(fragment) = &mut position.replay_events[0]
8607 else {
8608 unreachable!()
8609 };
8610
8611 fragment.last_px = Price::from("3101.00");
8612 }
8613 "opening_void" | "closing_void" => void_position_history_flip(
8614 &mut cache,
8615 &fill,
8616 source_id,
8617 destination_id,
8618 change == "closing_void",
8619 ),
8620 _ => unreachable!(),
8621 }
8622 }
8623
8624 let original_after =
8625 manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8626 if change == "missing_source" {
8627 report.venue_position_id = None;
8628 report.last_qty = Quantity::from("1.000");
8629 report.commission = Money::from("0.25 USDT");
8630 } else if change == "conflicting_fragment" {
8631 report.last_qty = Quantity::from("2.000");
8632 report.commission = Money::from("0.50 USDT");
8633 } else if change == "opening_void" {
8634 report.last_qty = Quantity::from("2.500");
8635 report.commission = Money::from("0.625 USDT");
8636 } else if change == "closing_void" {
8637 report.last_qty = Quantity::from("1.500");
8638 report.commission = Money::from("0.375 USDT");
8639 }
8640
8641 let after =
8642 manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8643 let scalar = manager.position_contains_fill_report(&report);
8644 let mixed = manager.position_fill_reports_contained_prefix(&[
8645 first,
8646 report.clone(),
8647 report.clone(),
8648 ]);
8649 let expected = !matches!(change, "missing_source" | "conflicting_fragment");
8650
8651 assert_eq!(before, 2);
8652 assert_eq!(original_after, if change == "unchanged" { 2 } else { 0 });
8653 assert_eq!(after, if expected { 2 } else { 0 });
8654 assert_eq!(scalar, expected);
8655
8656 let expected_mixed = match change {
8657 "missing_source" => 0,
8658 "conflicting_fragment" => 1,
8659 _ => 3,
8660 };
8661
8662 assert_eq!(mixed, expected_mixed);
8663 assert_eq!(
8664 manager.position_activity_revision(&(report.instrument_id, report.account_id)),
8665 0
8666 );
8667
8668 if expected {
8669 let cache = cache.borrow();
8670 let source = cache.position_ref(&source_id).unwrap();
8671 let destination = cache.position_ref(&destination_id).unwrap();
8672 assert_eq!(
8673 source.quantity,
8674 Quantity::from(if change == "closing_void" {
8675 "0.500"
8676 } else {
8677 "0.000"
8678 })
8679 );
8680 assert_eq!(
8681 destination.quantity,
8682 Quantity::from(match change {
8683 "closing_void" => "0.000",
8684 "opening_void" => "0.500",
8685 _ => "1.000",
8686 })
8687 );
8688 assert_eq!(
8689 source.commissions(),
8690 vec![Money::from(if change == "closing_void" {
8691 "0.505 USDT"
8692 } else {
8693 "0.63 USDT"
8694 })]
8695 );
8696
8697 let destination_commissions = if change == "closing_void" {
8698 Vec::new()
8699 } else {
8700 vec![Money::from(if change == "opening_void" {
8701 "0.125 USDT"
8702 } else {
8703 "0.25 USDT"
8704 })]
8705 };
8706
8707 assert_eq!(destination.commissions(), destination_commissions);
8708 }
8709 }
8710
8711 fn void_position_history_flip(
8712 cache: &mut Cache,
8713 fill: &OrderFilled,
8714 source_id: PositionId,
8715 destination_id: PositionId,
8716 closing_void: bool,
8717 ) {
8718 let correction = OrderFillVoidedSpec::builder()
8719 .trader_id(fill.trader_id)
8720 .strategy_id(fill.strategy_id)
8721 .instrument_id(fill.instrument_id)
8722 .client_order_id(fill.client_order_id)
8723 .venue_order_id(fill.venue_order_id)
8724 .account_id(fill.account_id)
8725 .trade_id(fill.trade_id)
8726 .voided_qty(Quantity::from(if closing_void { "1.500" } else { "0.500" }))
8727 .order_side(fill.order_side)
8728 .order_type(fill.order_type)
8729 .last_px(fill.last_px)
8730 .currency(fill.currency)
8731 .liquidity_side(fill.liquidity_side)
8732 .position_id(source_id)
8733 .commission_voided(Money::from(if closing_void {
8734 "0.375 USDT"
8735 } else {
8736 "0.125 USDT"
8737 }))
8738 .is_reopened(true)
8739 .build();
8740
8741 cache
8742 .position_mut(&destination_id)
8743 .unwrap()
8744 .apply_fill_void(
8745 correction.clone(),
8746 Quantity::from(if closing_void { "1.000" } else { "0.500" }),
8747 Some(Money::from(if closing_void {
8748 "0.25 USDT"
8749 } else {
8750 "0.125 USDT"
8751 })),
8752 )
8753 .unwrap();
8754
8755 if closing_void {
8756 cache
8757 .position_mut(&source_id)
8758 .unwrap()
8759 .apply_fill_void(
8760 correction,
8761 Quantity::from("0.500"),
8762 Some(Money::from("0.125 USDT")),
8763 )
8764 .unwrap();
8765 }
8766 }
8767
8768 fn position_history_fixture() -> (ExecutionManager, Rc<RefCell<Cache>>, FillReport) {
8769 let cache = Rc::new(RefCell::new(Cache::default()));
8770 let manager = ExecutionManager::new(
8771 Rc::new(RefCell::new(VirtualClock::new())),
8772 cache.clone(),
8773 ExecutionManagerConfig::default(),
8774 )
8775 .unwrap();
8776 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
8777 let order = OrderTestBuilder::new(OrderType::Market)
8778 .instrument_id(instrument.id())
8779 .client_order_id(ClientOrderId::from("O-HISTORY"))
8780 .side(OrderSide::Buy)
8781 .quantity(Quantity::from("10.000"))
8782 .build();
8783 let position_id = PositionId::from("P-HISTORY");
8784 let event = TestOrderEventStubs::filled(
8785 &order,
8786 &instrument,
8787 Some(TradeId::from("T-HISTORY")),
8788 Some(position_id),
8789 Some(Price::from("3100.00")),
8790 Some(Quantity::from("2.000")),
8791 Some(LiquiditySide::Taker),
8792 Some(Money::from("0.13 USDT")),
8793 None,
8794 Some(AccountId::from("TEST-001")),
8795 );
8796
8797 let OrderEventAny::Filled(fill) = event else {
8798 unreachable!()
8799 };
8800
8801 let report = FillReport::new(
8802 fill.account_id,
8803 fill.instrument_id,
8804 fill.venue_order_id,
8805 fill.trade_id,
8806 fill.order_side,
8807 fill.last_qty,
8808 fill.last_px,
8809 fill.commission.unwrap(),
8810 fill.liquidity_side,
8811 Some(fill.client_order_id),
8812 Some(position_id),
8813 fill.ts_event,
8814 fill.ts_init,
8815 None,
8816 );
8817 let position = Position::new(&instrument, fill);
8818 cache
8819 .borrow_mut()
8820 .add_position(&position, OmsType::Hedging)
8821 .unwrap();
8822 (manager, cache, report)
8823 }
8824
8825 #[rstest]
8826 fn test_plan_position_fill_reports_uses_configured_lookback() {
8827 let lookback_mins = 7_u64;
8828 let lookback = DurationNanos::from_mins(lookback_mins);
8829 let clock = Rc::new(RefCell::new(VirtualClock::new()));
8830 let cache = Rc::new(RefCell::new(Cache::default()));
8831
8832 let mut manager = ExecutionManager::new(
8833 clock.clone(),
8834 cache.clone(),
8835 ExecutionManagerConfig {
8836 position_check_lookback_mins: lookback_mins,
8837 position_check_threshold_ns: DurationNanos::ZERO,
8838 ..Default::default()
8839 },
8840 )
8841 .expect("valid config");
8842
8843 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
8844 cache
8845 .borrow_mut()
8846 .add_instrument(instrument.clone())
8847 .unwrap();
8848 let position = insert_open_position(
8849 &cache,
8850 &instrument,
8851 PositionId::from("P-FILL-LOOKBACK"),
8852 OrderSide::Buy,
8853 "1.0",
8854 "3000.00",
8855 );
8856 clock
8857 .borrow_mut()
8858 .advance_time(UnixNanos::default().saturating_add(lookback * 2), true);
8859 let client = PositionCoverageStubClient;
8860 let clients: [&dyn ExecutionClient; 1] = [&client];
8861 let mut check = manager.prepare_position_report_check(UUID4::new(), &clients);
8862 let query_end = clock.borrow().timestamp_ns();
8863
8864 let report = PositionStatusReport::new(
8865 position.account_id,
8866 position.instrument_id,
8867 PositionSide::Long,
8868 Quantity::from("2.0"),
8869 query_end,
8870 query_end,
8871 None,
8872 None,
8873 Some(dec!(3000.00)),
8874 );
8875 let queried_clients = IndexSet::from([client.client_id()]);
8876
8877 let plan = manager.plan_position_fill_reports(
8878 &mut check,
8879 &[report],
8880 &queried_clients,
8881 &IndexSet::new(),
8882 &clients,
8883 );
8884
8885 assert_eq!(
8886 plan.discrepancy_keys,
8887 IndexSet::from([(position.instrument_id, position.account_id)])
8888 );
8889 assert_eq!(plan.queries.len(), 1);
8890 let query = &plan.queries[0];
8891 assert_eq!(
8892 (query.key, query.client_id),
8893 (
8894 (position.instrument_id, position.account_id),
8895 client.client_id()
8896 )
8897 );
8898 assert_eq!(query.command.instrument_id, Some(position.instrument_id));
8899 assert_eq!(query.command.venue_order_id, None);
8900 assert_eq!(
8901 query.command.start,
8902 Some(query_end.saturating_sub(lookback))
8903 );
8904 assert_eq!(query.command.end, Some(query_end));
8905 assert_eq!(query.command.correlation_id, Some(check.command.command_id));
8906 assert_eq!(query.command.log_receipt_level, LogLevel::Debug);
8907 }
8908
8909 #[rstest]
8910 #[case::reported(Some("2.0"), true)]
8911 #[case::unreported(None, false)]
8912 fn test_plan_position_fill_reports_unavailable_coverage_requires_venue_report(
8913 #[case] venue_qty: Option<&str>,
8914 #[case] expect_query: bool,
8915 ) {
8916 let clock = Rc::new(RefCell::new(VirtualClock::new()));
8917 let cache = Rc::new(RefCell::new(Cache::default()));
8918
8919 let mut manager = ExecutionManager::new(
8920 clock.clone(),
8921 cache.clone(),
8922 ExecutionManagerConfig {
8923 position_check_threshold_ns: DurationNanos::ZERO,
8924 ..Default::default()
8925 },
8926 )
8927 .expect("valid config");
8928
8929 let spot = test_bybit_spot_instrument();
8930 cache.borrow_mut().add_instrument(spot.clone()).unwrap();
8931 let position = insert_open_position(
8932 &cache,
8933 &spot,
8934 PositionId::from("P-SPOT-UNAVAILABLE"),
8935 OrderSide::Buy,
8936 "1.0",
8937 "2000.00",
8938 );
8939 let key = (position.instrument_id, position.account_id);
8940 let client = PositionCoverageStubClient;
8941 let clients: [&dyn ExecutionClient; 1] = [&client];
8942 let mut check = manager.prepare_position_report_check(UUID4::new(), &clients);
8943 let ts_now = clock.borrow().timestamp_ns();
8944
8945 let reports: Vec<PositionStatusReport> = venue_qty
8946 .into_iter()
8947 .map(|qty| {
8948 PositionStatusReport::new(
8949 position.account_id,
8950 position.instrument_id,
8951 PositionSide::Long,
8952 Quantity::from(qty),
8953 ts_now,
8954 ts_now,
8955 None,
8956 None,
8957 Some(dec!(2000.00)),
8958 )
8959 })
8960 .collect();
8961
8962 let queried_clients = IndexSet::from([client.client_id()]);
8963
8964 let plan = manager.plan_position_fill_reports(
8965 &mut check,
8966 &reports,
8967 &queried_clients,
8968 &IndexSet::new(),
8969 &clients,
8970 );
8971
8972 let expected_queries = if expect_query {
8973 vec![(key, client.client_id())]
8974 } else {
8975 Vec::new()
8976 };
8977
8978 assert_eq!(
8979 check.client_coverage.get(&key),
8980 Some(&ReportClientCoverage::Unavailable(IndexSet::from([
8981 client.client_id()
8982 ])))
8983 );
8984 assert_eq!(plan.discrepancy_keys, IndexSet::from([key]));
8985 assert_eq!(
8986 plan.queries
8987 .iter()
8988 .map(|query| (query.key, query.client_id))
8989 .collect::<Vec<_>>(),
8990 expected_queries
8991 );
8992 }
8993
8994 #[rstest]
8995 fn test_plan_position_fill_reports_defers_position_opened_during_request() {
8996 let clock = Rc::new(RefCell::new(VirtualClock::new()));
8997 let cache = Rc::new(RefCell::new(Cache::default()));
8998
8999 let mut manager = ExecutionManager::new(
9000 clock,
9001 cache.clone(),
9002 ExecutionManagerConfig {
9003 position_check_threshold_ns: DurationNanos::ZERO,
9004 ..Default::default()
9005 },
9006 )
9007 .expect("valid config");
9008
9009 let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
9010 cache
9011 .borrow_mut()
9012 .add_instrument(instrument.clone())
9013 .unwrap();
9014 let client = PositionCoverageStubClient;
9015 let clients: [&dyn ExecutionClient; 1] = [&client];
9016 let mut check = manager.prepare_position_report_check(UUID4::new(), &clients);
9017 let position = insert_open_position(
9018 &cache,
9019 &instrument,
9020 PositionId::from("P-FILL-DURING-REQUEST"),
9021 OrderSide::Buy,
9022 "1.0",
9023 "3000.00",
9024 );
9025 manager.record_position_activity(position.instrument_id, position.account_id);
9026
9027 let report = PositionStatusReport::new(
9028 position.account_id,
9029 position.instrument_id,
9030 PositionSide::Long,
9031 Quantity::from("2.0"),
9032 UnixNanos::from(1_000_000),
9033 UnixNanos::from(1_000_000),
9034 None,
9035 None,
9036 Some(dec!(3000.00)),
9037 );
9038
9039 let plan = manager.plan_position_fill_reports(
9040 &mut check,
9041 &[report],
9042 &IndexSet::from([client.client_id()]),
9043 &IndexSet::new(),
9044 &clients,
9045 );
9046
9047 assert_eq!(
9048 plan.discrepancy_keys,
9049 IndexSet::from([(position.instrument_id, position.account_id)])
9050 );
9051 assert!(plan.queries.is_empty());
9052 assert_eq!(
9053 check
9054 .activity_revisions
9055 .get(&(position.instrument_id, position.account_id)),
9056 Some(&0)
9057 );
9058 }
9059
9060 #[rstest]
9061 fn test_prepare_position_report_check_uses_live_client_bulk_coverage() {
9062 let clock = Rc::new(RefCell::new(VirtualClock::new()));
9063 let cache = Rc::new(RefCell::new(Cache::default()));
9064 let manager =
9065 ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
9066 .expect("valid config");
9067 let derivative = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
9068 let spot = test_bybit_spot_instrument();
9069 cache
9070 .borrow_mut()
9071 .add_instrument(derivative.clone())
9072 .unwrap();
9073 cache.borrow_mut().add_instrument(spot.clone()).unwrap();
9074 let derivative_position = insert_open_position(
9075 &cache,
9076 &derivative,
9077 PositionId::from("P-DERIVATIVE-COVERAGE"),
9078 OrderSide::Buy,
9079 "5.0",
9080 "3000.00",
9081 );
9082 let spot_position = insert_open_position(
9083 &cache,
9084 &spot,
9085 PositionId::from("P-SPOT-COVERAGE"),
9086 OrderSide::Buy,
9087 "2.0",
9088 "2000.00",
9089 );
9090 let client = LiveExecutionClient::new(Box::new(PositionCoverageStubClient));
9091 let client: &dyn ExecutionClient = &client;
9092
9093 let check = manager.prepare_position_report_check(UUID4::new(), &[client]);
9094 let client_id = ClientId::from("BYBIT");
9095
9096 assert_eq!(
9097 check.client_coverage.get(&(
9098 derivative_position.instrument_id,
9099 derivative_position.account_id
9100 )),
9101 Some(&ReportClientCoverage::Resolved(IndexSet::from([client_id])))
9102 );
9103 assert_eq!(
9104 check
9105 .client_coverage
9106 .get(&(spot_position.instrument_id, spot_position.account_id)),
9107 Some(&ReportClientCoverage::Unavailable(IndexSet::from([
9108 client_id
9109 ])))
9110 );
9111 }
9112 }
9113}