Skip to main content

nautilus_live/execution/
manager.rs

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