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