Skip to main content

nautilus_model/
position.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//! Market positions, replay history, and checked financial arithmetic.
17//!
18//! [`Position`] tracks open and closed positions from fills, adjustments, and instrument settlement.
19//! It records quantity, side, average prices, commissions, and realized PnL.
20//!
21//! # Replay
22//!
23//! The replay journal records fills, adjustments, and instrument close events. Retained history
24//! supports price restatements and cumulative fill corrections across close and reopen cycles.
25//!
26//! # Checked Arithmetic
27//!
28//! Financial calculations use checked domain types and [`Decimal`]. The shared arithmetic also
29//! supports account projections and splitting fills for position reversals.
30//!
31//! - Input conversions reject precision loss and overflow.
32//! - Derived products, cost sums, division, and proportional intermediates round at Decimal precision.
33//!   Cost allocations retain a representable remainder.
34//! - Arithmetic rejects a nonzero operand or result that would disappear at that precision.
35//!   PnL sums may absorb a disappearing residual smaller than one native settlement [`Money`] unit.
36//! - Derived [`Money`] values round midpoint to even at their native fixed-point scale.
37
38use std::{
39    fmt::Display,
40    hash::{Hash, Hasher},
41};
42
43use ahash::{AHashMap, AHashSet};
44use indexmap::IndexMap;
45use nautilus_core::{
46    DurationNanos, UUID4, UnixNanos,
47    correctness::{
48        CorrectnessError, CorrectnessResult, CorrectnessResultExt, FAILED, check_equal,
49        check_predicate_true,
50    },
51};
52use ruint::aliases::{U256, U512};
53use rust_decimal::Decimal;
54use serde::{Deserialize, Serialize};
55
56use crate::{
57    data::InstrumentClose,
58    enums::{
59        InstrumentClass, InstrumentCloseType, OrderSide, PositionAdjustmentType, PositionSide,
60    },
61    events::{OrderFillVoided, OrderFilled, PositionAdjusted},
62    identifiers::{
63        AccountId, ClientOrderId, InstrumentId, PositionId, StrategyId, Symbol, TradeId, TraderId,
64        Venue, VenueOrderId,
65    },
66    instruments::{Instrument, InstrumentAny},
67    types::{
68        Currency, Money, Price, Quantity,
69        fixed::{FIXED_PRECISION, FIXED_SCALAR_RAW, checked_mul_div_raw, raw_scales_match},
70        quantity::QuantityRaw,
71    },
72};
73
74/// An open or closed position in a market.
75///
76/// # Identity and Replay
77///
78/// The venue may assign the position ID; the strategy's Order Management System (OMS) settings
79/// control system-generated IDs. Retained replay events and cumulative fill corrections preserve
80/// derived state across close and reopen cycles.
81///
82/// # Accounting
83///
84/// Financial calculations use checked domain and [`Decimal`] arithmetic. Decimal has a 96-bit
85/// coefficient and a maximum scale of 28. Input conversions reject precision loss and overflow;
86/// derived products, cost sums, division, and proportional intermediates use its finite precision.
87///
88/// - Cost accumulators preserve the cost basis without reusing rounded average prices.
89/// - Partial reductions retain unallocated cost; the final reduction consumes it.
90/// - A sub-Money PnL remainder preserves fractional amounts between updates.
91///
92/// [`Money`] results round midpoint to even at their native fixed-point scale. `realized_return`
93/// is a floating-point analytics projection and does not feed accounting.
94#[repr(C)]
95#[derive(Debug, Clone, Serialize, Deserialize)]
96#[cfg_attr(
97    feature = "python",
98    pyo3::pyclass(module = "nautilus_trader.model", from_py_object)
99)]
100#[cfg_attr(
101    feature = "python",
102    pyo3_stub_gen::derive::gen_stub_pyclass(module = "nautilus_trader.model")
103)]
104pub struct Position {
105    pub events: Vec<OrderFilled>,
106    pub adjustments: Vec<PositionAdjusted>,
107    #[serde(default)]
108    pub replay_events: Vec<PositionReplayEvent>,
109    #[serde(default)]
110    pub fill_voids: Vec<PositionFillVoid>,
111    pub trader_id: TraderId,
112    pub strategy_id: StrategyId,
113    pub instrument_id: InstrumentId,
114    pub id: PositionId,
115    pub account_id: AccountId,
116    pub opening_order_id: ClientOrderId,
117    pub closing_order_id: Option<ClientOrderId>,
118    pub entry: OrderSide,
119    pub side: PositionSide,
120    pub signed_qty: Decimal,
121    pub quantity: Quantity,
122    pub peak_qty: Quantity,
123    pub price_precision: u8,
124    pub size_precision: u8,
125    pub multiplier: Quantity,
126    pub is_inverse: bool,
127    pub is_currency_pair: bool,
128    pub instrument_class: InstrumentClass,
129    pub base_currency: Option<Currency>,
130    pub quote_currency: Currency,
131    pub settlement_currency: Currency,
132    pub ts_init: UnixNanos,
133    pub ts_opened: UnixNanos,
134    pub ts_last: UnixNanos,
135    pub ts_closed: Option<UnixNanos>,
136    pub duration_ns: DurationNanos,
137    pub avg_px_open: Decimal,
138    pub avg_px_close: Option<Decimal>,
139    pub realized_return: f64,
140    pub realized_pnl: Option<Money>,
141    #[serde(with = "nautilus_core::serialization::sorted_hashset")]
142    pub trade_ids: AHashSet<TradeId>,
143    /// Total buy quantity in the current position episode.
144    pub buy_qty: Quantity,
145    /// Total sell quantity in the current position episode.
146    pub sell_qty: Quantity,
147    pub commissions: IndexMap<Currency, Money>,
148    pub cost_open: Decimal,
149    pub cost_close: Decimal,
150    pub qty_closed: Decimal,
151    pub realized_pnl_remainder: Decimal,
152    /// The instrument's negative-price allowance, absent in older serialized positions.
153    #[serde(default, skip_serializing_if = "Option::is_none")]
154    pub allows_negative_price: Option<bool>,
155}
156
157#[expect(clippy::large_enum_variant)]
158#[derive(Debug, Clone, Serialize, Deserialize)]
159pub enum PositionReplayEvent {
160    Filled(OrderFilled),
161    Adjusted(PositionAdjusted),
162    InstrumentClosed(InstrumentClose),
163}
164
165#[derive(Debug, Clone, Serialize, Deserialize)]
166pub struct PositionFillVoid {
167    pub event: OrderFillVoided,
168    pub voided_qty: Quantity,
169    pub commission_voided: Option<Money>,
170}
171
172impl Position {
173    /// Creates a new [`Position`] instance.
174    ///
175    /// # Panics
176    ///
177    /// Panics if [`Position::new_checked`] returns an error.
178    #[must_use]
179    #[allow(
180        clippy::needless_pass_by_value,
181        reason = "constructor takes the opening fill by value as the position's seed event"
182    )]
183    pub fn new(instrument: &InstrumentAny, fill: OrderFilled) -> Self {
184        Self::new_checked(instrument, fill).expect_display(FAILED)
185    }
186
187    /// Creates a new [`Position`] instance with correctness checking.
188    ///
189    /// # Errors
190    ///
191    /// Returns an error if the instrument ID does not match the fill, the fill has no position
192    /// ID, or its accounting values cannot be represented without input precision loss.
193    #[allow(
194        clippy::needless_pass_by_value,
195        reason = "constructor takes the opening fill by value as the position's seed event"
196    )]
197    pub fn new_checked(instrument: &InstrumentAny, fill: OrderFilled) -> CorrectnessResult<Self> {
198        Self::check_fill_instrument(instrument.id(), "instrument.id()", &fill)?;
199        let position_id = Self::fill_position_id(&fill)?;
200
201        let mut item = Self {
202            events: Vec::<OrderFilled>::new(),
203            adjustments: Vec::<PositionAdjusted>::new(),
204            replay_events: Vec::new(),
205            fill_voids: Vec::new(),
206            trade_ids: AHashSet::<TradeId>::new(),
207            buy_qty: Quantity::zero(instrument.size_precision()),
208            sell_qty: Quantity::zero(instrument.size_precision()),
209            commissions: IndexMap::<Currency, Money>::new(),
210            trader_id: fill.trader_id,
211            strategy_id: fill.strategy_id,
212            instrument_id: fill.instrument_id,
213            id: position_id,
214            account_id: fill.account_id,
215            opening_order_id: fill.client_order_id,
216            closing_order_id: None,
217            entry: fill.order_side,
218            side: PositionSide::Flat,
219            signed_qty: Decimal::ZERO,
220            quantity: fill.last_qty,
221            peak_qty: fill.last_qty,
222            price_precision: instrument.price_precision(),
223            size_precision: instrument.size_precision(),
224            multiplier: instrument.multiplier(),
225            is_inverse: instrument.is_inverse(),
226            is_currency_pair: matches!(
227                instrument,
228                InstrumentAny::CurrencyPair(_) | InstrumentAny::TokenizedAsset(_)
229            ),
230            instrument_class: instrument.instrument_class(),
231            base_currency: instrument.base_currency(),
232            quote_currency: instrument.quote_currency(),
233            settlement_currency: instrument.cost_currency(),
234            ts_init: fill.ts_init,
235            ts_opened: fill.ts_event,
236            ts_last: fill.ts_event,
237            ts_closed: None,
238            duration_ns: DurationNanos::default(),
239            avg_px_open: price(fill.last_px)?,
240            avg_px_close: None,
241            realized_return: 0.0,
242            realized_pnl: None,
243            cost_open: Decimal::ZERO,
244            cost_close: Decimal::ZERO,
245            qty_closed: Decimal::ZERO,
246            realized_pnl_remainder: Decimal::ZERO,
247            allows_negative_price: Some(instrument.allows_negative_price()),
248        };
249
250        item.check_accounting()?;
251        item.apply_fill(&fill, true)?;
252        Ok(item)
253    }
254
255    /// Returns a copy without stored events, adjustments, replay events, fill voids, or trade IDs.
256    ///
257    /// # Warning
258    ///
259    /// Use this copy only as transient read state. Applying events or caching this copy can bypass
260    /// replay and duplicate-fill checks and discard position history.
261    #[must_use]
262    pub fn clone_without_events(&self) -> Self {
263        Self {
264            events: Vec::new(),
265            adjustments: Vec::new(),
266            replay_events: Vec::new(),
267            fill_voids: Vec::new(),
268            trader_id: self.trader_id,
269            strategy_id: self.strategy_id,
270            instrument_id: self.instrument_id,
271            id: self.id,
272            account_id: self.account_id,
273            opening_order_id: self.opening_order_id,
274            closing_order_id: self.closing_order_id,
275            entry: self.entry,
276            side: self.side,
277            signed_qty: self.signed_qty,
278            quantity: self.quantity,
279            peak_qty: self.peak_qty,
280            price_precision: self.price_precision,
281            size_precision: self.size_precision,
282            multiplier: self.multiplier,
283            is_inverse: self.is_inverse,
284            is_currency_pair: self.is_currency_pair,
285            instrument_class: self.instrument_class,
286            base_currency: self.base_currency,
287            quote_currency: self.quote_currency,
288            settlement_currency: self.settlement_currency,
289            ts_init: self.ts_init,
290            ts_opened: self.ts_opened,
291            ts_last: self.ts_last,
292            ts_closed: self.ts_closed,
293            duration_ns: self.duration_ns,
294            avg_px_open: self.avg_px_open,
295            avg_px_close: self.avg_px_close,
296            realized_return: self.realized_return,
297            realized_pnl: self.realized_pnl,
298            trade_ids: AHashSet::new(),
299            buy_qty: self.buy_qty,
300            sell_qty: self.sell_qty,
301            commissions: self.commissions.clone(),
302            cost_open: self.cost_open,
303            cost_close: self.cost_close,
304            qty_closed: self.qty_closed,
305            realized_pnl_remainder: self.realized_pnl_remainder,
306            allows_negative_price: self.allows_negative_price,
307        }
308    }
309
310    /// Returns a snapshot copy without durable replay or fill-void history.
311    #[must_use]
312    pub fn clone_for_snapshot(&self) -> Self {
313        let mut snapshot = self.clone_without_events();
314        snapshot.events.clone_from(&self.events);
315        snapshot.adjustments.clone_from(&self.adjustments);
316        snapshot.trade_ids.clone_from(&self.trade_ids);
317        snapshot
318    }
319
320    /// Moves durable replay state from `prior` and keeps this position's current replay events.
321    pub fn transfer_replay_state_from(&mut self, prior: &mut Self) {
322        let current_replay = std::mem::take(&mut self.replay_events);
323        self.replay_events = std::mem::take(&mut prior.replay_events);
324        self.fill_voids = std::mem::take(&mut prior.fill_voids);
325        self.replay_events.extend(current_replay);
326    }
327
328    /// Purges all order fill events for the given client order ID and recalculates derived state.
329    ///
330    /// # Warning
331    ///
332    /// This operation recalculates the entire position from scratch after removing the specified
333    /// order's fills. This is an expensive operation and should be used sparingly.
334    ///
335    /// # Errors
336    ///
337    /// Returns an error if the remaining history cannot be represented. An error leaves the
338    /// position unchanged.
339    pub fn purge_events_for_order(
340        &mut self,
341        client_order_id: ClientOrderId,
342    ) -> CorrectnessResult<()> {
343        let mut next = self.clone();
344        next.purge_order(client_order_id)?;
345        *self = next;
346        Ok(())
347    }
348
349    fn purge_order(&mut self, client_order_id: ClientOrderId) -> CorrectnessResult<()> {
350        self.replay_events.retain(|event| {
351            !matches!(event, PositionReplayEvent::Filled(fill) if fill.client_order_id == client_order_id)
352        });
353        self.fill_voids
354            .retain(|record| record.event.client_order_id != client_order_id);
355
356        let filtered_events: Vec<OrderFilled> = self
357            .events
358            .iter()
359            .filter(|e| e.client_order_id != client_order_id)
360            .cloned()
361            .collect();
362
363        // Preserve non-commission adjustments (funding, manual adjustments, etc.)
364        // Commission adjustments will be automatically re-created when fills are replayed
365        let preserved_adjustments: Vec<PositionAdjusted> = self
366            .adjustments
367            .iter()
368            .filter(|adj| {
369                // Keep all non-commission adjustments (funding, manual, etc.)
370                // Commission adjustments will be re-created during fill replay
371                adj.adjustment_type != PositionAdjustmentType::Commission
372            })
373            .copied()
374            .collect();
375
376        // If no events remain, log warning - position should be closed/removed instead
377        if filtered_events.is_empty() {
378            log::warn!(
379                "Position {} has no fills remaining after purging order {}; consider closing the position instead",
380                self.id,
381                client_order_id
382            );
383            self.clear_derived_state();
384            return Ok(());
385        }
386
387        // Recalculate position from scratch
388        let position_id = self.id;
389        self.reset_derived_state();
390
391        // Use the first remaining event to set opening state
392        let first_event = &filtered_events[0];
393        self.entry = first_event.order_side;
394        self.opening_order_id = first_event.client_order_id;
395        self.ts_opened = first_event.ts_event;
396        self.ts_init = first_event.ts_init;
397        self.closing_order_id = None;
398        self.ts_closed = None;
399        self.duration_ns = DurationNanos::default();
400
401        self.replay_retained_fills(&filtered_events)?;
402
403        // Reapply preserved adjustments to maintain full state
404        for adjustment in preserved_adjustments {
405            self.apply_adjustment_state(adjustment, false)?;
406        }
407
408        log::info!(
409            "Purged fills for order {} from position {}; recalculated state: qty={}, signed_qty={}, side={:?}",
410            client_order_id,
411            position_id,
412            self.quantity,
413            self.signed_qty,
414            self.side
415        );
416        Ok(())
417    }
418
419    fn replay_retained_fills(&mut self, filtered_events: &[OrderFilled]) -> CorrectnessResult<()> {
420        let first_event = &filtered_events[0];
421        let restatement_indexes = Self::price_restatement_indexes(&self.replay_events);
422
423        let start = self.replay_events.iter().position(|event| {
424            matches!(
425                event,
426                PositionReplayEvent::Filled(fill) if fill.event_id == first_event.event_id
427            )
428        });
429
430        let remaining_orders: AHashSet<_> = filtered_events
431            .iter()
432            .map(|event| event.client_order_id)
433            .collect();
434        let effective_by_id: AHashMap<_, _> = filtered_events
435            .iter()
436            .map(|event| (event.event_id, event))
437            .collect();
438
439        if let Some(start) = start {
440            let replay = self.replay_events.clone();
441            for (index, event) in replay.iter().enumerate().skip(start) {
442                let PositionReplayEvent::Filled(fill) = event else {
443                    continue;
444                };
445
446                if !remaining_orders.contains(&fill.client_order_id) {
447                    continue;
448                }
449
450                if restatement_indexes.contains(&index) {
451                    self.apply_price_restatement(fill, false)?;
452                } else if let Some(effective) = effective_by_id.get(&fill.event_id) {
453                    self.apply_fill(effective, false)?;
454                }
455            }
456        } else {
457            for event in filtered_events {
458                self.apply_fill(event, false)?;
459            }
460        }
461
462        Ok(())
463    }
464
465    /// Applies an `OrderFilled` event to this position.
466    ///
467    /// A fill with the same `trade_id`, the same `client_order_id`, and a new price restates
468    /// the open average when that trade is an opening fill in the current cycle. Quantity is
469    /// unchanged. The original fill stays in `events`, so a void still matches its `last_px`.
470    /// Applying the same `event_id` again does nothing. A different order that reuses the trade
471    /// ID is rejected. A closing fill does not change the open average, and restating an
472    /// opening fill does not change realized PnL for quantity already closed.
473    ///
474    /// # Panics
475    ///
476    /// Panics if the fill is rejected as a duplicate trade or fails accounting validation.
477    pub fn apply(&mut self, fill: &OrderFilled) {
478        self.apply_fill(fill, true).expect_display(FAILED);
479    }
480
481    /// Applies an `OrderFilled` event to this position with correctness checking.
482    ///
483    /// A fill with the same `trade_id`, the same `client_order_id`, and a new price restates
484    /// the open average when that trade is an opening fill in the current cycle. Quantity is
485    /// unchanged. An error leaves the position unchanged. Applying the same `event_id` again
486    /// does nothing. A closing fill does not change the open average.
487    ///
488    /// # Errors
489    ///
490    /// Returns an error if:
491    /// - The fill instrument or position identity does not match this position.
492    /// - The fill has no position ID.
493    /// - An accounting input or intermediate exceeds the supported Decimal or domain bounds.
494    /// - `fill.trade_id` is already in `trade_ids` and this fill is not a restatement of that
495    ///   order.
496    pub fn try_apply(&mut self, fill: &OrderFilled) -> CorrectnessResult<()> {
497        Self::check_fill_instrument(self.instrument_id, "self.instrument_id", fill)?;
498        let position_id = Self::fill_position_id(fill)?;
499        check_equal(&self.id, &position_id, "self.id", "fill.position_id")?;
500        self.apply_fill(fill, true)
501    }
502
503    fn replay_has_event(&self, event_id: UUID4) -> bool {
504        self.replay_events.iter().any(|event| {
505            matches!(
506                event,
507                PositionReplayEvent::Filled(existing) if existing.event_id == event_id
508            )
509        })
510    }
511
512    fn check_fill_instrument(
513        instrument_id: InstrumentId,
514        instrument_param: &str,
515        fill: &OrderFilled,
516    ) -> CorrectnessResult<()> {
517        check_equal(
518            &instrument_id,
519            &fill.instrument_id,
520            instrument_param,
521            "fill.instrument_id",
522        )
523    }
524
525    fn fill_position_id(fill: &OrderFilled) -> CorrectnessResult<PositionId> {
526        fill.position_id
527            .ok_or_else(|| CorrectnessError::PredicateViolation {
528                message: "`fill.position_id` was None".to_string(),
529            })
530    }
531
532    fn check_fill_accounting(&self, fill: &OrderFilled) -> CorrectnessResult<(Decimal, Decimal)> {
533        let last_px = price(fill.last_px)?;
534        let last_qty = qty(fill.last_qty)?;
535        if let Some(commission) = fill.commission {
536            amount(commission)?;
537        }
538
539        Ok((last_px, last_qty))
540    }
541
542    /// Checks that stored domain inputs fit the exact Decimal accounting bounds.
543    ///
544    /// # Errors
545    ///
546    /// Returns an error if a stored price, quantity, or monetary input loses precision or overflows.
547    pub fn check_accounting(&self) -> CorrectnessResult<()> {
548        for quantity in [
549            self.quantity,
550            self.peak_qty,
551            self.buy_qty,
552            self.sell_qty,
553            self.multiplier,
554        ] {
555            qty(quantity)?;
556        }
557
558        for amount in self.commissions.values().copied().chain(self.realized_pnl) {
559            self::amount(amount)?;
560        }
561
562        for fill in &self.events {
563            self.check_fill_accounting(fill)?;
564        }
565
566        for event in &self.replay_events {
567            match event {
568                PositionReplayEvent::Filled(fill) => {
569                    self.check_fill_accounting(fill)?;
570                }
571                PositionReplayEvent::InstrumentClosed(close) => {
572                    price(close.close_price)?;
573                }
574                PositionReplayEvent::Adjusted(_) => {}
575            }
576        }
577
578        Ok(())
579    }
580
581    fn apply_fill(&mut self, fill: &OrderFilled, record_replay: bool) -> CorrectnessResult<()> {
582        if record_replay
583            && self.trade_ids.contains(&fill.trade_id)
584            && self.replay_has_event(fill.event_id)
585        {
586            return Ok(());
587        }
588
589        let (last_px, last_qty) = self.check_fill_accounting(fill)?;
590
591        if self.is_price_restatement(fill) {
592            let mut next = self.clone();
593            next.apply_price_restatement(fill, record_replay)?;
594            *self = next;
595            return Ok(());
596        }
597
598        if record_replay
599            && (self.side == PositionSide::Flat || !self.trade_ids.contains(&fill.trade_id))
600            && self.is_duplicate_replay_fill(fill)
601        {
602            log::warn!(
603                "Ignoring historical duplicate fill {} for position {}; durable replay already contains this trade",
604                fill.trade_id,
605                self.id,
606            );
607            return Ok(());
608        }
609
610        if fill.ts_event < self.ts_opened {
611            log::warn!(
612                "Fill ts_event {} for {} is before position ts_opened {}",
613                fill.ts_event,
614                self.id,
615                self.ts_opened,
616            );
617        }
618
619        let resets = self.side == PositionSide::Flat;
620        if record_replay && !resets {
621            check_predicate_true(
622                !self.trade_ids.contains(&fill.trade_id),
623                "`fill.trade_id` already contained in `trade_ids`",
624            )?;
625        }
626
627        let mut next = self.prepare_fill(fill, last_px, last_qty)?;
628        if !resets {
629            next.events = std::mem::take(&mut self.events);
630            next.trade_ids = std::mem::take(&mut self.trade_ids);
631            let mut adjustments = std::mem::take(&mut self.adjustments);
632            adjustments.append(&mut next.adjustments);
633            next.adjustments = adjustments;
634        }
635
636        next.replay_events = std::mem::take(&mut self.replay_events);
637        next.fill_voids = std::mem::take(&mut self.fill_voids);
638        next.events.push(fill.clone());
639        next.trade_ids.insert(fill.trade_id);
640        if record_replay {
641            next.replay_events
642                .push(PositionReplayEvent::Filled(fill.clone()));
643        }
644
645        next.debug_assert_invariants();
646        *self = next;
647        Ok(())
648    }
649
650    fn prepare_fill(
651        &self,
652        fill: &OrderFilled,
653        last_px: Decimal,
654        last_qty: Decimal,
655    ) -> CorrectnessResult<Self> {
656        let mut next = self.clone_without_events();
657        if self.side == PositionSide::Flat {
658            next.reset_cycle(fill)?;
659        }
660
661        if let Some(commission) = fill.commission {
662            let total = match next.commissions.get(&commission.currency) {
663                Some(total) => total
664                    .checked_add(commission)
665                    .ok_or_else(|| invalid("position commission overflow"))?,
666                None => commission,
667            };
668
669            next.commissions.insert(commission.currency, total);
670        }
671
672        next.handle_order_fill(fill, last_px, last_qty)?;
673        if next.is_currency_pair
674            && let Some(commission) = fill.commission
675            && next.base_currency == Some(commission.currency)
676        {
677            next.apply_base_commission_adjustment(fill, commission)?;
678        }
679
680        next.quantity = quantity(next.signed_qty.abs(), next.size_precision)?;
681        next.peak_qty = next.peak_qty.max(next.quantity);
682        if next.quantity.is_zero() {
683            next.side = PositionSide::Flat;
684            next.signed_qty = Decimal::ZERO;
685            next.closing_order_id = Some(fill.client_order_id);
686            next.ts_closed = Some(fill.ts_event);
687            next.duration_ns = fill.ts_event.saturating_duration_since(next.ts_opened);
688        } else if next.signed_qty > Decimal::ZERO {
689            next.entry = OrderSide::Buy;
690            next.side = PositionSide::Long;
691        } else {
692            next.entry = OrderSide::Sell;
693            next.side = PositionSide::Short;
694        }
695
696        next.ts_last = fill.ts_event;
697        Ok(next)
698    }
699
700    fn reset_cycle(&mut self, fill: &OrderFilled) -> CorrectnessResult<()> {
701        self.events.clear();
702        self.trade_ids.clear();
703        self.adjustments.clear();
704        self.buy_qty = Quantity::zero(self.size_precision);
705        self.sell_qty = Quantity::zero(self.size_precision);
706        self.commissions.clear();
707        self.opening_order_id = fill.client_order_id;
708        self.closing_order_id = None;
709        self.peak_qty = Quantity::zero(self.size_precision);
710        self.ts_init = fill.ts_init;
711        self.ts_opened = fill.ts_event;
712        self.ts_closed = None;
713        self.duration_ns = DurationNanos::default();
714        self.avg_px_open = price(fill.last_px)?;
715        self.avg_px_close = None;
716        self.realized_return = 0.0;
717        self.realized_pnl = None;
718        self.cost_open = Decimal::ZERO;
719        self.cost_close = Decimal::ZERO;
720        self.qty_closed = Decimal::ZERO;
721        self.realized_pnl_remainder = Decimal::ZERO;
722        Ok(())
723    }
724
725    /// Returns whether durable replay history contains `trade_id`.
726    #[must_use]
727    pub fn has_replay_trade_id(&self, trade_id: TradeId) -> bool {
728        self.replay_events.iter().any(
729            |event| matches!(event, PositionReplayEvent::Filled(fill) if fill.trade_id == trade_id),
730        )
731    }
732
733    fn is_duplicate_replay_fill(&self, fill: &OrderFilled) -> bool {
734        let continues_latest_fill = fill.causation_id.is_some_and(|source_id| {
735            self.events.last().is_some_and(|latest| {
736                latest.trade_id == fill.trade_id && latest.event_id == source_id
737            })
738        });
739
740        if self.trade_ids.contains(&fill.trade_id) {
741            return !continues_latest_fill
742                || self.replay_events.iter().any(|event| {
743                    matches!(
744                        event,
745                        PositionReplayEvent::Filled(replayed)
746                            if replayed.trade_id == fill.trade_id
747                                && replayed.causation_id == fill.causation_id
748                    )
749                });
750        }
751
752        let replay_starts_current_cycle = self.replay_events.is_empty()
753            || matches!(
754                (self.replay_events.first(), self.events.first()),
755                (
756                    Some(PositionReplayEvent::Filled(replayed)),
757                    Some(current),
758                ) if replayed.event_id == current.event_id
759            );
760        let corrected_trade = self
761            .fill_voids
762            .iter()
763            .any(|record| record.event.trade_id == fill.trade_id);
764        let current_cycle_only = replay_starts_current_cycle && !corrected_trade;
765        if current_cycle_only {
766            return false;
767        }
768
769        self.has_replay_trade_id(fill.trade_id)
770    }
771
772    /// Returns whether the fill can restate an opening trade's price in the current episode.
773    ///
774    /// The order, trade, side, and quantity must match the recorded opening fill.
775    #[must_use]
776    pub fn accepts_price_restatement(&self, fill: &OrderFilled) -> bool {
777        if !self.is_open()
778            || !self.trade_ids.contains(&fill.trade_id)
779            || fill.order_side != self.entry
780        {
781            return false;
782        }
783
784        let Some(existing) = self.events.iter().find(|event| {
785            event.trade_id == fill.trade_id && event.client_order_id == fill.client_order_id
786        }) else {
787            return false;
788        };
789
790        if existing.last_qty != fill.last_qty {
791            return false;
792        }
793
794        let mut latest = None;
795
796        for event in &self.replay_events {
797            let PositionReplayEvent::Filled(existing) = event else {
798                continue;
799            };
800
801            if existing.trade_id == fill.trade_id
802                && existing.client_order_id == fill.client_order_id
803            {
804                latest = Some(existing.last_px);
805            }
806        }
807
808        latest.is_some_and(|price| price != fill.last_px)
809    }
810
811    fn is_price_restatement(&self, fill: &OrderFilled) -> bool {
812        if self.side == PositionSide::Flat
813            || self.quantity.is_zero()
814            || !self.trade_ids.contains(&fill.trade_id)
815        {
816            return false;
817        }
818
819        let mut latest = None;
820
821        for event in &self.replay_events {
822            let PositionReplayEvent::Filled(existing) = event else {
823                continue;
824            };
825
826            if existing.trade_id != fill.trade_id
827                || existing.client_order_id != fill.client_order_id
828            {
829                continue;
830            }
831
832            if existing.event_id == fill.event_id {
833                return latest.is_some_and(|price| price != fill.last_px);
834            }
835
836            latest = Some(existing.last_px);
837        }
838
839        latest.is_some_and(|price| price != fill.last_px)
840    }
841
842    fn apply_price_restatement(
843        &mut self,
844        fill: &OrderFilled,
845        record_replay: bool,
846    ) -> CorrectnessResult<()> {
847        if self.side != PositionSide::Flat && !self.quantity.is_zero() {
848            self.restate_open_average(fill)?;
849        }
850
851        self.ts_last = fill.ts_event;
852
853        if record_replay {
854            self.replay_events
855                .push(PositionReplayEvent::Filled(fill.clone()));
856        }
857
858        Ok(())
859    }
860
861    fn has_replay_price_restatement(&self) -> bool {
862        let mut seen = AHashMap::new();
863
864        for event in &self.replay_events {
865            let PositionReplayEvent::Filled(fill) = event else {
866                continue;
867            };
868
869            if let Some(price) = seen.get(&fill.trade_id) {
870                if *price != fill.last_px {
871                    return true;
872                }
873            } else {
874                seen.insert(fill.trade_id, fill.last_px);
875            }
876        }
877
878        false
879    }
880
881    fn restate_open_average(&mut self, fill: &OrderFilled) -> CorrectnessResult<()> {
882        if !self.trade_ids.contains(&fill.trade_id)
883            || fill.order_side != self.entry
884            || !self.extends_current_cycle(fill)?
885        {
886            return Ok(());
887        }
888
889        let new_px = price(fill.last_px)?;
890
891        let Some(previous_px) = self.accounting_px_before(fill)? else {
892            return Ok(());
893        };
894
895        let open_qty = qty(self.quantity)?;
896        let trade_qty = self.cycle_open_qty_for_trade(fill.trade_id)?.min(open_qty);
897        if open_qty.is_zero() || trade_qty.is_zero() {
898            return Ok(());
899        }
900
901        let delta = mul_rounded(sub(new_px, previous_px)?, trade_qty)?;
902        self.cost_open = add_rounded(self.cost_open, delta)?;
903        self.avg_px_open = div(self.cost_open, open_qty)?;
904        Ok(())
905    }
906
907    fn extends_current_cycle(&self, fill: &OrderFilled) -> CorrectnessResult<bool> {
908        let long = self.entry == OrderSide::Buy;
909        let mut signed = Decimal::ZERO;
910
911        for event in &self.events {
912            let qty = qty(event.last_qty)?;
913            let delta = if event.order_side == OrderSide::Buy {
914                qty
915            } else {
916                -qty
917            };
918
919            let after = add(signed, delta)?;
920            if event.trade_id == fill.trade_id && event.client_order_id == fill.client_order_id {
921                return Ok((signed.is_zero() || (signed > Decimal::ZERO) == long)
922                    && ((after > Decimal::ZERO) == long));
923            }
924
925            signed = after;
926        }
927
928        Ok(false)
929    }
930
931    fn cycle_open_qty_for_trade(&self, trade_id: TradeId) -> CorrectnessResult<Decimal> {
932        let long = self.entry == OrderSide::Buy;
933        let mut remaining: Vec<(TradeId, Decimal)> = Vec::new();
934        let mut signed = Decimal::ZERO;
935
936        for fill in &self.events {
937            let qty = qty(fill.last_qty)?;
938            let delta = if fill.order_side == OrderSide::Buy {
939                qty
940            } else {
941                -qty
942            };
943
944            let after = add(signed, delta)?;
945            if !signed.is_zero() && (after > Decimal::ZERO) != (signed > Decimal::ZERO) {
946                remaining.clear();
947                if !after.is_zero() && (after > Decimal::ZERO) == long {
948                    remaining.push((fill.trade_id, after.abs()));
949                }
950            } else if fill.order_side == self.entry {
951                remaining.push((fill.trade_id, qty));
952            } else {
953                Self::reduce_open_lots(&mut remaining, qty)?;
954            }
955
956            signed = after;
957        }
958
959        remaining
960            .into_iter()
961            .filter(|(id, _)| *id == trade_id)
962            .try_fold(Decimal::ZERO, |total, (_, qty)| add_rounded(total, qty))
963    }
964
965    fn reduce_open_lots(
966        remaining: &mut [(TradeId, Decimal)],
967        qty: Decimal,
968    ) -> CorrectnessResult<()> {
969        let open_qty = remaining
970            .iter()
971            .try_fold(Decimal::ZERO, |total, (_, qty)| add_rounded(total, *qty))?;
972
973        if !open_qty.is_zero() {
974            let keep = div(sub(open_qty, qty.min(open_qty))?, open_qty)?;
975            for (_, qty) in remaining {
976                *qty = mul_rounded(*qty, keep)?;
977            }
978        }
979
980        Ok(())
981    }
982
983    fn accounting_px_before(&self, fill: &OrderFilled) -> CorrectnessResult<Option<Decimal>> {
984        let mut price = None;
985
986        for event in &self.replay_events {
987            let PositionReplayEvent::Filled(existing) = event else {
988                continue;
989            };
990
991            if existing.trade_id != fill.trade_id {
992                continue;
993            }
994
995            if existing.event_id == fill.event_id {
996                break;
997            }
998
999            price = Some(self::price(existing.last_px)?);
1000        }
1001
1002        Ok(price)
1003    }
1004
1005    fn voidable_replay_fill<'a>(
1006        restatement_indexes: &AHashSet<usize>,
1007        index: usize,
1008        replay_event: &'a PositionReplayEvent,
1009    ) -> Option<&'a OrderFilled> {
1010        let PositionReplayEvent::Filled(fill) = replay_event else {
1011            return None;
1012        };
1013
1014        if restatement_indexes.contains(&index) {
1015            return None;
1016        }
1017
1018        Some(fill)
1019    }
1020
1021    fn price_restatement_indexes(replay_events: &[PositionReplayEvent]) -> AHashSet<usize> {
1022        let mut latest_px = AHashMap::new();
1023        let mut indexes = AHashSet::new();
1024
1025        for (index, event) in replay_events.iter().enumerate() {
1026            let PositionReplayEvent::Filled(fill) = event else {
1027                continue;
1028            };
1029
1030            let key = (fill.trade_id, fill.client_order_id);
1031            if let Some(price) = latest_px.get(&key)
1032                && *price != fill.last_px
1033            {
1034                indexes.insert(index);
1035            }
1036
1037            latest_px.insert(key, fill.last_px);
1038        }
1039
1040        indexes
1041    }
1042
1043    fn handle_order_fill(
1044        &mut self,
1045        fill: &OrderFilled,
1046        last_px: Decimal,
1047        last_qty: Decimal,
1048    ) -> CorrectnessResult<()> {
1049        check_predicate_true(last_qty > Decimal::ZERO, "fill quantity must be positive")?;
1050        let prior_qty = self.signed_qty.abs();
1051        let increases = self.signed_qty.is_zero()
1052            || (self.signed_qty > Decimal::ZERO) == (fill.order_side == OrderSide::Buy);
1053        let mut pnl = Decimal::ZERO;
1054
1055        if increases {
1056            self.cost_open = add_rounded(self.cost_open, mul_rounded(last_px, last_qty)?)?;
1057            self.avg_px_open = div(self.cost_open, add(prior_qty, last_qty)?)?;
1058        } else {
1059            pnl = self.close_fill(last_px, last_qty.min(prior_qty), prior_qty)?;
1060            if last_qty > prior_qty {
1061                let opening_qty = sub(last_qty, prior_qty)?;
1062                self.cost_open = mul_rounded(last_px, opening_qty)?;
1063                self.avg_px_open = last_px;
1064                self.avg_px_close = None;
1065                self.realized_return = 0.0;
1066                self.cost_close = Decimal::ZERO;
1067                self.qty_closed = Decimal::ZERO;
1068                self.buy_qty = Quantity::zero(self.size_precision);
1069                self.sell_qty = Quantity::zero(self.size_precision);
1070            }
1071        }
1072
1073        let commission = fill
1074            .commission
1075            .filter(|commission| commission.currency == self.settlement_currency)
1076            .map(amount)
1077            .transpose()?
1078            .unwrap_or(Decimal::ZERO);
1079        pnl = add_pnl(pnl, -commission, self.settlement_currency)?;
1080        self.accumulate_pnl(pnl)?;
1081
1082        let signed = if fill.order_side == OrderSide::Buy {
1083            last_qty
1084        } else {
1085            -last_qty
1086        };
1087
1088        self.signed_qty = add(self.signed_qty, signed)?;
1089
1090        let qty = if !increases && last_qty > prior_qty {
1091            quantity(sub(last_qty, prior_qty)?, self.size_precision)?
1092        } else {
1093            fill.last_qty
1094        };
1095
1096        let cumulative = if fill.order_side == OrderSide::Buy {
1097            &mut self.buy_qty
1098        } else {
1099            &mut self.sell_qty
1100        };
1101
1102        *cumulative = quantity_add(*cumulative, qty, self.size_precision)?;
1103
1104        Ok(())
1105    }
1106
1107    fn close_fill(
1108        &mut self,
1109        last_px: Decimal,
1110        closing_qty: Decimal,
1111        prior_qty: Decimal,
1112    ) -> CorrectnessResult<Decimal> {
1113        let allocated_cost = if closing_qty == prior_qty {
1114            self.cost_open
1115        } else {
1116            proportion(self.cost_open, closing_qty, prior_qty)?
1117        };
1118
1119        let pnl = self.pnl_from_cost(
1120            last_px,
1121            closing_qty,
1122            allocated_cost,
1123            prior_qty,
1124            self.cost_open,
1125        )?;
1126        self.cost_open = sub(self.cost_open, allocated_cost)?;
1127        self.cost_close = add_rounded(self.cost_close, mul_rounded(last_px, closing_qty)?)?;
1128        self.qty_closed = add(self.qty_closed, closing_qty)?;
1129        self.avg_px_close = Some(div(self.cost_close, self.qty_closed)?);
1130        self.realized_return = self.calculate_return(
1131            self.avg_px_open,
1132            self.avg_px_close.expect("closing average is set"),
1133        );
1134
1135        Ok(pnl)
1136    }
1137
1138    fn accumulate_pnl(&mut self, change: Decimal) -> CorrectnessResult<()> {
1139        let prior = self.realized_decimal()?;
1140        let total = add_pnl(prior, change, self.settlement_currency)?;
1141        let rounded = money(total, self.settlement_currency)?;
1142        self.realized_pnl_remainder = sub(total, amount(rounded)?)?;
1143        self.realized_pnl = Some(rounded);
1144        Ok(())
1145    }
1146
1147    fn realized_decimal(&self) -> CorrectnessResult<Decimal> {
1148        let prior = match self.realized_pnl {
1149            Some(pnl) => {
1150                check_equal(
1151                    &pnl.currency,
1152                    &self.settlement_currency,
1153                    "realized_pnl.currency",
1154                    "settlement_currency",
1155                )?;
1156                amount(pnl)?
1157            }
1158            None => Decimal::ZERO,
1159        };
1160
1161        add(prior, self.realized_pnl_remainder)
1162    }
1163
1164    fn pnl_from_cost(
1165        &self,
1166        last_px: Decimal,
1167        qty: Decimal,
1168        cost: Decimal,
1169        prior_qty: Decimal,
1170        basis_cost: Decimal,
1171    ) -> CorrectnessResult<Decimal> {
1172        let difference = if self
1173            .instrument_class
1174            .divides_notional_by_price(self.is_inverse)
1175        {
1176            check_predicate_true(
1177                self.base_currency.is_some(),
1178                "inverse position requires base currency",
1179            )?;
1180            check_predicate_true(
1181                last_px > Decimal::ZERO && basis_cost > Decimal::ZERO,
1182                "inverse prices must be positive",
1183            )?;
1184            let entry = div(prior_qty, basis_cost)?;
1185            let exit = div(Decimal::ONE, last_px)?;
1186            mul_rounded(qty, add_rounded(entry, -exit)?)?
1187        } else {
1188            add_rounded(mul_rounded(last_px, qty)?, -cost)?
1189        };
1190
1191        let difference = if self.signed_qty < Decimal::ZERO {
1192            -difference
1193        } else {
1194            difference
1195        };
1196
1197        if self.multiplier.precision <= FIXED_PRECISION && self.multiplier.raw == FIXED_SCALAR_RAW {
1198            return Ok(difference);
1199        }
1200
1201        mul_rounded(difference, self::qty(self.multiplier)?)
1202    }
1203
1204    /// Applies a position adjustment event.
1205    ///
1206    /// This method handles adjustments to position quantity or realized PnL that occur
1207    /// outside of normal order fills, such as:
1208    /// - Commission adjustments in base currency (crypto spot markets).
1209    /// - Funding payments (perpetual futures).
1210    ///
1211    /// The adjustment event is stored in the position's adjustment history for full audit trail.
1212    ///
1213    /// # Errors
1214    ///
1215    /// Returns an error if currencies differ, arithmetic overflows, or a quantity change
1216    /// cannot be represented.
1217    /// An error leaves the position unchanged.
1218    pub fn apply_adjustment(&mut self, adjustment: PositionAdjusted) -> CorrectnessResult<()> {
1219        self.apply_adjustment_state(adjustment, true)
1220    }
1221
1222    /// Reverts the most recent adjustment applied with [`Self::apply_adjustment`].
1223    ///
1224    /// `prior` is a snapshot of this position taken before that adjustment was applied, for
1225    /// example with [`Self::clone_without_events`]; the state an adjustment changes is restored
1226    /// from it, and the adjustment is removed from the position history.
1227    ///
1228    /// An adjustment can leave every field the snapshot is checked on unchanged, for example a
1229    /// zero value funding payment, so the snapshot must also not be older than the latest
1230    /// adjustment that stays in the history. This assumes adjustments are applied in timestamp
1231    /// order, as the backtest does; a stale snapshot behind out of order adjustments can pass.
1232    ///
1233    /// # Errors
1234    ///
1235    /// Returns an error if `prior` is a snapshot of a different position, size precision or
1236    /// settlement currency, the last replay event is not the latest adjustment (for example a
1237    /// fill was applied after it), `prior` predates the adjustment before the latest one, its
1238    /// realized PnL cannot take the adjustment's PnL change (another currency, or out of
1239    /// `Money` bounds), or applying that adjustment to `prior` does not reproduce the current
1240    /// state. An error leaves the position unchanged.
1241    pub fn revert_last_adjustment(&mut self, prior: &Self) -> CorrectnessResult<()> {
1242        check_equal(&self.id, &prior.id, "self.id", "prior.id")?;
1243        check_equal(
1244            &self.size_precision,
1245            &prior.size_precision,
1246            "self.size_precision",
1247            "prior.size_precision",
1248        )?;
1249        check_equal(
1250            &self.settlement_currency,
1251            &prior.settlement_currency,
1252            "self.settlement_currency",
1253            "prior.settlement_currency",
1254        )?;
1255
1256        let adjustment = match (self.replay_events.last(), self.adjustments.last()) {
1257            (Some(PositionReplayEvent::Adjusted(replayed)), Some(latest)) if replayed == latest => {
1258                *latest
1259            }
1260            _ => {
1261                return Err(CorrectnessError::PredicateViolation {
1262                    message: format!(
1263                        "cannot revert adjustment for position {}: the last replay event is not its latest adjustment",
1264                        self.id
1265                    ),
1266                });
1267            }
1268        };
1269
1270        if let Some(earlier) = self.adjustments.iter().rev().nth(1)
1271            && prior.ts_last < earlier.ts_event
1272        {
1273            return Err(CorrectnessError::PredicateViolation {
1274                message: format!(
1275                    "cannot revert adjustment {} for position {}: `prior` at {} predates adjustment {} at {}",
1276                    adjustment.event_id, self.id, prior.ts_last, earlier.event_id, earlier.ts_event
1277                ),
1278            });
1279        }
1280
1281        // Checked here because adding to a realized PnL in another currency panics
1282        if let (Some(realized_pnl), Some(pnl_change)) = (prior.realized_pnl, adjustment.pnl_change)
1283            && (realized_pnl.currency != pnl_change.currency
1284                || realized_pnl.checked_add(pnl_change).is_none())
1285        {
1286            return Err(CorrectnessError::PredicateViolation {
1287                message: format!(
1288                    "cannot revert adjustment {} for position {}: `prior` realized PnL {realized_pnl} cannot take the PnL change {pnl_change}",
1289                    adjustment.event_id, self.id
1290                ),
1291            });
1292        }
1293
1294        let mut expected = prior.clone_without_events();
1295        expected.apply_adjustment_state(adjustment, false)?;
1296
1297        if expected.signed_qty != self.signed_qty
1298            || expected.quantity != self.quantity
1299            || expected.peak_qty != self.peak_qty
1300            || expected.side != self.side
1301            || expected.cost_open != self.cost_open
1302            || expected.realized_pnl_remainder != self.realized_pnl_remainder
1303            || expected.realized_pnl != self.realized_pnl
1304            || expected.ts_last != self.ts_last
1305        {
1306            return Err(CorrectnessError::PredicateViolation {
1307                message: format!(
1308                    "cannot revert adjustment {} for position {}: `prior` is not the state before it",
1309                    adjustment.event_id, self.id
1310                ),
1311            });
1312        }
1313
1314        self.adjustments.pop();
1315        self.replay_events.pop();
1316        self.signed_qty = prior.signed_qty;
1317        self.quantity = prior.quantity;
1318        self.peak_qty = prior.peak_qty;
1319        self.side = prior.side;
1320        self.realized_pnl = prior.realized_pnl;
1321        self.cost_open = prior.cost_open;
1322        self.realized_pnl_remainder = prior.realized_pnl_remainder;
1323        self.ts_last = prior.ts_last;
1324
1325        self.debug_assert_invariants();
1326        Ok(())
1327    }
1328
1329    fn apply_adjustment_state(
1330        &mut self,
1331        adjustment: PositionAdjusted,
1332        record_replay: bool,
1333    ) -> CorrectnessResult<()> {
1334        let signed_qty = add(
1335            self.signed_qty,
1336            adjustment.quantity_change.unwrap_or(Decimal::ZERO),
1337        )?;
1338        let quantity = quantity(signed_qty.abs(), self.size_precision)?;
1339
1340        let cost_open = if adjustment.quantity_change.is_some() {
1341            if self.signed_qty.is_zero() {
1342                mul_rounded(self.avg_px_open, signed_qty.abs())?
1343            } else {
1344                proportion(self.cost_open, signed_qty.abs(), self.signed_qty.abs())?
1345            }
1346        } else {
1347            self.cost_open
1348        };
1349
1350        let (realized_pnl, remainder) = if let Some(change) = adjustment.pnl_change {
1351            check_equal(
1352                &change.currency,
1353                &self.settlement_currency,
1354                "adjustment.currency",
1355                "settlement_currency",
1356            )?;
1357            let prior = self.realized_decimal()?;
1358            let total = add_pnl(prior, amount(change)?, self.settlement_currency)?;
1359            let rounded = money(total, self.settlement_currency)?;
1360            (Some(rounded), sub(total, amount(rounded)?)?)
1361        } else {
1362            (self.realized_pnl, self.realized_pnl_remainder)
1363        };
1364
1365        self.signed_qty = signed_qty;
1366        self.quantity = quantity;
1367        self.peak_qty = self.peak_qty.max(quantity);
1368        self.cost_open = cost_open;
1369        self.realized_pnl = realized_pnl;
1370        self.realized_pnl_remainder = remainder;
1371
1372        self.side = if signed_qty.is_zero() {
1373            PositionSide::Flat
1374        } else if signed_qty > Decimal::ZERO {
1375            PositionSide::Long
1376        } else {
1377            PositionSide::Short
1378        };
1379
1380        self.adjustments.push(adjustment);
1381
1382        if record_replay {
1383            self.replay_events
1384                .push(PositionReplayEvent::Adjusted(adjustment));
1385        }
1386
1387        self.ts_last = adjustment.ts_event;
1388        self.debug_assert_invariants();
1389        Ok(())
1390    }
1391
1392    /// Settles the open position at the payout price of an authoritative contract expiration.
1393    ///
1394    /// The settlement closes the current cycle at `close.close_price` and books its realized PnL
1395    /// without an order fill. Fill quantities and commissions stay as filled. The close is
1396    /// recorded in the replay history, so [`Self::is_settled`] holds until a later fill reopens
1397    /// the position.
1398    ///
1399    /// # Errors
1400    ///
1401    /// Returns an error if the close targets another instrument, is not a contract expiration,
1402    /// the position is not open, or the settlement PnL cannot be represented. An error leaves the
1403    /// position unchanged.
1404    pub fn apply_instrument_close(&mut self, close: InstrumentClose) -> anyhow::Result<()> {
1405        anyhow::ensure!(
1406            close.instrument_id == self.instrument_id,
1407            "instrument close {} does not match position instrument {}",
1408            close.instrument_id,
1409            self.instrument_id,
1410        );
1411        anyhow::ensure!(
1412            close.close_type == InstrumentCloseType::ContractExpired,
1413            "instrument close for {} is not a contract expiration",
1414            close.instrument_id,
1415        );
1416        anyhow::ensure!(
1417            self.is_open(),
1418            "cannot settle position {} which is not open",
1419            self.id,
1420        );
1421
1422        self.apply_instrument_close_state(close, true)
1423    }
1424
1425    fn apply_instrument_close_state(
1426        &mut self,
1427        close: InstrumentClose,
1428        record_replay: bool,
1429    ) -> anyhow::Result<()> {
1430        if self.side == PositionSide::Flat {
1431            return Ok(());
1432        }
1433
1434        let last_px = price(close.close_price)?;
1435        let qty = self.signed_qty.abs();
1436        let cost_close = add_rounded(self.cost_close, mul_rounded(last_px, qty)?)?;
1437        let qty_closed = add(self.qty_closed, qty)?;
1438        let avg_px_close = div(cost_close, qty_closed)?;
1439        let realized_return = self.calculate_return(self.avg_px_open, avg_px_close);
1440        let pnl = self.pnl_from_cost(last_px, qty, self.cost_open, qty, self.cost_open)?;
1441        self.accumulate_pnl(pnl)?;
1442
1443        if record_replay {
1444            self.replay_events
1445                .push(PositionReplayEvent::InstrumentClosed(close));
1446        }
1447
1448        self.avg_px_close = Some(avg_px_close);
1449        self.realized_return = realized_return;
1450        self.cost_open = Decimal::ZERO;
1451        self.cost_close = cost_close;
1452        self.qty_closed = qty_closed;
1453        self.side = PositionSide::Flat;
1454        self.signed_qty = Decimal::ZERO;
1455        self.quantity = Quantity::zero(self.size_precision);
1456        self.closing_order_id = None;
1457        self.ts_last = close.ts_event;
1458        self.ts_closed = Some(close.ts_event);
1459        self.duration_ns = close.ts_event.saturating_duration_since(self.ts_opened);
1460        self.debug_assert_invariants();
1461        Ok(())
1462    }
1463
1464    fn debug_assert_invariants(&self) {
1465        debug_assert!(
1466            match self.side {
1467                PositionSide::Long => self.signed_qty > Decimal::ZERO,
1468                PositionSide::Short => self.signed_qty < Decimal::ZERO,
1469                PositionSide::Flat => self.signed_qty == Decimal::ZERO,
1470            },
1471            "Invariant: position side must match signed_qty sign (side={:?}, signed_qty={})",
1472            self.side,
1473            self.signed_qty,
1474        );
1475        debug_assert!(
1476            self.peak_qty >= self.quantity,
1477            "Invariant: peak_qty must not be less than current quantity (peak={}, quantity={})",
1478            self.peak_qty,
1479            self.quantity,
1480        );
1481    }
1482
1483    /// Applies a cumulative fill correction allocated to this position and rebuilds derived state.
1484    ///
1485    /// Returns the realized PnL of the cycles the rebuild closed before the current one, which
1486    /// [`Self::realized_pnl`] no longer holds because reopening from flat resets it. A caller
1487    /// archiving closed cycles needs this to keep their PnL once the correction has moved the
1488    /// cycle boundaries its existing archive describes. `None` when no closed cycle precedes the
1489    /// current one, so it covers the entire corrected history.
1490    ///
1491    /// # Errors
1492    ///
1493    /// Returns an error if the allocation is stale, duplicated, exceeds known fragments, or has a
1494    /// commission currency that differs from those fragments.
1495    pub fn apply_fill_void(
1496        &mut self,
1497        event: OrderFillVoided,
1498        voided_qty: Quantity,
1499        commission_voided: Option<Money>,
1500    ) -> anyhow::Result<Option<Money>> {
1501        let fragments = self.fill_fragments(event.client_order_id, event.trade_id);
1502
1503        qty(voided_qty)?;
1504
1505        let fragment_qty = fragments
1506            .iter()
1507            .try_fold(Quantity::zero(self.size_precision), |total, fill| {
1508                quantity_add(total, fill.last_qty, self.size_precision)
1509            })?;
1510
1511        anyhow::ensure!(
1512            !voided_qty.is_zero() && voided_qty <= fragment_qty,
1513            "position fill void exceeds known fragments for {}",
1514            event.trade_id,
1515        );
1516
1517        if let Some(commission_voided) = commission_voided {
1518            for commission in fragments.iter().filter_map(|fill| fill.commission) {
1519                anyhow::ensure!(
1520                    commission.currency == commission_voided.currency,
1521                    "position commission currency differs for fill {}",
1522                    event.trade_id,
1523                );
1524            }
1525        }
1526
1527        if let Some(previous) = self.fill_voids.iter().rev().find(|record| {
1528            record.event.client_order_id == event.client_order_id
1529                && record.event.trade_id == event.trade_id
1530        }) {
1531            anyhow::ensure!(
1532                voided_qty >= previous.voided_qty,
1533                "stale position fill void for {}",
1534                event.trade_id,
1535            );
1536            anyhow::ensure!(
1537                voided_qty != previous.voided_qty
1538                    || commission_voided != previous.commission_voided,
1539                "duplicate position fill void for {}",
1540                event.trade_id,
1541            );
1542        }
1543
1544        let mut next = self.clone();
1545        next.fill_voids.push(PositionFillVoid {
1546            event,
1547            voided_qty,
1548            commission_voided,
1549        });
1550
1551        let closed = next.rebuild_from_replay()?;
1552        *self = next;
1553        Ok(closed)
1554    }
1555
1556    /// Returns durable fill fragments matching an order trade in local application order.
1557    #[must_use]
1558    pub fn fill_fragments(
1559        &self,
1560        client_order_id: ClientOrderId,
1561        trade_id: TradeId,
1562    ) -> Vec<&OrderFilled> {
1563        let restatement_indexes = Self::price_restatement_indexes(&self.replay_events);
1564        self.replay_events
1565            .iter()
1566            .enumerate()
1567            .filter_map(|(index, event)| match event {
1568                PositionReplayEvent::Filled(fill)
1569                    if fill.client_order_id == client_order_id
1570                        && fill.trade_id == trade_id
1571                        && !restatement_indexes.contains(&index) =>
1572                {
1573                    Some(fill)
1574                }
1575                _ => None,
1576            })
1577            .collect()
1578    }
1579
1580    // The banked total assumes `replay_events` spans every cycle this position archived, since
1581    // settling replaces all of its frames with one worth that total. Bounding the log has to
1582    // preserve it at trim time; `Cache::settle_position_snapshots` documents the two ways.
1583    fn rebuild_from_replay(&mut self) -> CorrectnessResult<Option<Money>> {
1584        let replay_events = self.replay_events.clone();
1585        let restatement_indexes = Self::price_restatement_indexes(&replay_events);
1586        let mut quantity_removed = AHashMap::<usize, Quantity>::new();
1587        let mut commission_removed = AHashMap::<usize, Money>::new();
1588
1589        for correction in self.latest_fill_voids() {
1590            Self::allocate_fill_void(
1591                &replay_events,
1592                correction,
1593                &restatement_indexes,
1594                &mut quantity_removed,
1595                &mut commission_removed,
1596            )?;
1597        }
1598
1599        self.reset_derived_state();
1600
1601        let mut closed_cycles_pnl: Option<Money> = None;
1602
1603        for (index, replay_event) in replay_events.iter().enumerate() {
1604            match replay_event {
1605                PositionReplayEvent::Filled(fill) => {
1606                    if restatement_indexes.contains(&index) {
1607                        self.apply_price_restatement(fill, false)?;
1608                        continue;
1609                    }
1610
1611                    let removed = quantity_removed
1612                        .get(&index)
1613                        .copied()
1614                        .unwrap_or_else(|| Quantity::zero(fill.last_qty.precision));
1615                    let effective_qty =
1616                        quantity_sub(fill.last_qty, removed, fill.last_qty.precision)?;
1617
1618                    let effective_commission =
1619                        match (fill.commission, commission_removed.get(&index).copied()) {
1620                            (Some(commission), Some(removed)) => Some(commission - removed),
1621                            (commission, None) => commission,
1622                            (None, Some(_)) => None,
1623                        };
1624
1625                    self.replay_fill(
1626                        fill,
1627                        effective_qty,
1628                        effective_commission,
1629                        &mut closed_cycles_pnl,
1630                    )?;
1631                }
1632                PositionReplayEvent::Adjusted(adjustment) => {
1633                    self.apply_adjustment_state(*adjustment, false)?;
1634                }
1635                PositionReplayEvent::InstrumentClosed(close) => {
1636                    self.apply_instrument_close_state(*close, false)
1637                        .map_err(|e| invalid(&e.to_string()))?;
1638                }
1639            }
1640        }
1641
1642        Ok(closed_cycles_pnl)
1643    }
1644
1645    fn replay_fill(
1646        &mut self,
1647        fill: &OrderFilled,
1648        effective_qty: Quantity,
1649        effective_commission: Option<Money>,
1650        closed_cycles_pnl: &mut Option<Money>,
1651    ) -> CorrectnessResult<()> {
1652        if effective_qty.is_zero() {
1653            if let Some(commission) =
1654                effective_commission.filter(|commission| !commission.is_zero())
1655                && let Some(realized_pnl) =
1656                    self.apply_surviving_fill_commission(fill, commission)?
1657            {
1658                *closed_cycles_pnl = Some(Self::bank_closed_cycle_pnl(
1659                    *closed_cycles_pnl,
1660                    realized_pnl,
1661                )?);
1662            }
1663
1664            return Ok(());
1665        }
1666
1667        // `apply_fill` clears realized PnL when it reopens from flat, so bank the
1668        // closing cycle's total before it goes
1669        if self.side == PositionSide::Flat
1670            && let Some(realized_pnl) = self.realized_pnl
1671        {
1672            *closed_cycles_pnl = Some(Self::bank_closed_cycle_pnl(
1673                *closed_cycles_pnl,
1674                realized_pnl,
1675            )?);
1676        }
1677
1678        let mut effective = fill.clone();
1679        effective.last_qty = effective_qty;
1680        effective.commission = effective_commission;
1681        self.apply_fill(&effective, false)
1682    }
1683
1684    fn allocate_fill_void(
1685        replay_events: &[PositionReplayEvent],
1686        correction: &PositionFillVoid,
1687        restatement_indexes: &AHashSet<usize>,
1688        quantity_removed: &mut AHashMap<usize, Quantity>,
1689        commission_removed: &mut AHashMap<usize, Money>,
1690    ) -> CorrectnessResult<()> {
1691        let mut remaining_qty = correction.voided_qty;
1692        let mut remaining_commission = correction.commission_voided;
1693
1694        for (index, replay_event) in replay_events.iter().enumerate().rev() {
1695            let Some(fill) = Self::voidable_replay_fill(restatement_indexes, index, replay_event)
1696            else {
1697                continue;
1698            };
1699
1700            if fill.client_order_id != correction.event.client_order_id
1701                || fill.trade_id != correction.event.trade_id
1702            {
1703                continue;
1704            }
1705
1706            if !remaining_qty.is_zero() {
1707                let removed = remaining_qty.min(fill.last_qty);
1708                quantity_removed.insert(index, removed);
1709                remaining_qty = quantity_sub(remaining_qty, removed, remaining_qty.precision)?;
1710            }
1711
1712            if let (Some(remaining), Some(commission)) = (remaining_commission, fill.commission) {
1713                let magnitude = remaining.abs().min(commission.abs());
1714                let removed = if remaining.is_negative() {
1715                    -magnitude
1716                } else {
1717                    magnitude
1718                };
1719
1720                commission_removed.insert(index, removed);
1721                let next = remaining - removed;
1722                remaining_commission = (!next.is_zero()).then_some(next);
1723            }
1724        }
1725
1726        Ok(())
1727    }
1728
1729    fn bank_closed_cycle_pnl(
1730        total: Option<Money>,
1731        realized_pnl: Money,
1732    ) -> CorrectnessResult<Money> {
1733        total.map_or(Ok(realized_pnl), |total| {
1734            total
1735                .checked_add(realized_pnl)
1736                .ok_or_else(|| invalid("closed cycle PnL overflow"))
1737        })
1738    }
1739
1740    fn apply_surviving_fill_commission(
1741        &mut self,
1742        fill: &OrderFilled,
1743        commission: Money,
1744    ) -> CorrectnessResult<Option<Money>> {
1745        let is_base_commission =
1746            self.is_currency_pair && self.base_currency == Some(commission.currency);
1747        let reopens =
1748            self.side == PositionSide::Flat && is_base_commission && !amount(commission)?.is_zero();
1749        let closed_cycles_pnl_previous = reopens.then_some(self.realized_pnl).flatten();
1750
1751        if reopens {
1752            self.reset_cycle(fill)?;
1753        }
1754
1755        self.commissions
1756            .entry(commission.currency)
1757            .or_insert(Money::zero(commission.currency));
1758        let total = self.commissions[&commission.currency]
1759            .checked_add(commission)
1760            .ok_or_else(|| invalid("position commission overflow"))?;
1761        self.commissions.insert(commission.currency, total);
1762        if commission.currency == self.settlement_currency {
1763            self.accumulate_pnl(-amount(commission)?)?;
1764        }
1765
1766        if is_base_commission {
1767            let previous_side = self.side;
1768            self.apply_base_commission_adjustment(fill, commission)?;
1769            self.finalize_surviving_base_commission(fill, previous_side)?;
1770        } else {
1771            self.ts_last = fill.ts_event;
1772        }
1773
1774        Ok(closed_cycles_pnl_previous)
1775    }
1776
1777    fn finalize_surviving_base_commission(
1778        &mut self,
1779        fill: &OrderFilled,
1780        previous_side: PositionSide,
1781    ) -> CorrectnessResult<()> {
1782        if self.side == PositionSide::Flat {
1783            if previous_side != PositionSide::Flat {
1784                self.closing_order_id = Some(fill.client_order_id);
1785                self.ts_closed = Some(fill.ts_event);
1786                self.duration_ns = fill.ts_event.saturating_duration_since(self.ts_opened);
1787            }
1788        } else {
1789            self.entry = match self.side {
1790                PositionSide::Long => OrderSide::Buy,
1791                PositionSide::Short => OrderSide::Sell,
1792                PositionSide::Flat => unreachable!(),
1793            };
1794
1795            if previous_side != PositionSide::Flat && previous_side != self.side {
1796                self.avg_px_open = price(fill.last_px)?;
1797                self.cost_open = mul_rounded(self.avg_px_open, self.signed_qty.abs())?;
1798            }
1799        }
1800
1801        Ok(())
1802    }
1803
1804    fn apply_base_commission_adjustment(
1805        &mut self,
1806        fill: &OrderFilled,
1807        commission: Money,
1808    ) -> CorrectnessResult<()> {
1809        let mut adjustment_id = fill.event_id.as_bytes();
1810        adjustment_id[15] ^= 0x01;
1811
1812        let adjustment = PositionAdjusted::new(
1813            self.trader_id,
1814            self.strategy_id,
1815            self.instrument_id,
1816            self.id,
1817            self.account_id,
1818            PositionAdjustmentType::Commission,
1819            Some(-amount(commission)?),
1820            None,
1821            Some(fill.client_order_id.inner()),
1822            UUID4::from_bytes(adjustment_id),
1823            fill.ts_event,
1824            fill.ts_init,
1825        );
1826        self.apply_adjustment_state(adjustment, false)
1827    }
1828
1829    fn latest_fill_voids(&self) -> Vec<&PositionFillVoid> {
1830        let mut latest = IndexMap::<(ClientOrderId, TradeId), &PositionFillVoid>::new();
1831        for correction in &self.fill_voids {
1832            latest.insert(
1833                (correction.event.client_order_id, correction.event.trade_id),
1834                correction,
1835            );
1836        }
1837        latest.into_values().collect()
1838    }
1839
1840    fn reset_derived_state(&mut self) {
1841        self.clear_derived_state();
1842        self.peak_qty = Quantity::zero(self.size_precision);
1843        self.avg_px_open = Decimal::ZERO;
1844        self.closing_order_id = None;
1845    }
1846
1847    fn clear_derived_state(&mut self) {
1848        // Empty purge retains legacy peak quantity, opening average, and closing order metadata
1849        self.events.clear();
1850        self.trade_ids.clear();
1851        self.adjustments.clear();
1852        self.buy_qty = Quantity::zero(self.size_precision);
1853        self.sell_qty = Quantity::zero(self.size_precision);
1854        self.commissions.clear();
1855        self.signed_qty = Decimal::ZERO;
1856        self.quantity = Quantity::zero(self.size_precision);
1857        self.side = PositionSide::Flat;
1858        self.avg_px_close = None;
1859        self.realized_pnl = None;
1860        self.realized_return = 0.0;
1861        self.ts_opened = UnixNanos::default();
1862        self.ts_last = UnixNanos::default();
1863        self.ts_closed = Some(UnixNanos::default());
1864        self.duration_ns = DurationNanos::default();
1865        self.cost_open = Decimal::ZERO;
1866        self.cost_close = Decimal::ZERO;
1867        self.qty_closed = Decimal::ZERO;
1868        self.realized_pnl_remainder = Decimal::ZERO;
1869    }
1870
1871    fn calculate_return(&self, open: Decimal, close: Decimal) -> f64 {
1872        if open.is_zero() {
1873            return 0.0;
1874        }
1875
1876        let open = open.as_f64();
1877        let close = close.as_f64();
1878        let points = if self.side == PositionSide::Short {
1879            open - close
1880        } else {
1881            close - open
1882        };
1883
1884        points / open
1885    }
1886
1887    /// Returns the realized PnL increment for reducing this position at `last`.
1888    ///
1889    /// Carries the position's existing fractional PnL into the native Money rounding.
1890    ///
1891    /// # Errors
1892    ///
1893    /// Returns an error if inverse prices are invalid, precision is unsupported, or arithmetic overflows.
1894    pub fn try_realized_pnl(&self, last: Price, quantity: Quantity) -> CorrectnessResult<Money> {
1895        let qty = qty(quantity)?.min(self.signed_qty.abs());
1896        if qty.is_zero() {
1897            return Ok(Money::zero(self.settlement_currency));
1898        }
1899
1900        let cost = if qty == self.signed_qty.abs() {
1901            self.cost_open
1902        } else {
1903            proportion(self.cost_open, qty, self.signed_qty.abs())?
1904        };
1905
1906        let pnl = self.pnl_from_cost(
1907            price(last)?,
1908            qty,
1909            cost,
1910            self.signed_qty.abs(),
1911            self.cost_open,
1912        )?;
1913        let prior = self.realized_decimal()?;
1914        let total = add_pnl(prior, pnl, self.settlement_currency)?;
1915        let rounded = money(total, self.settlement_currency)?;
1916        rounded
1917            .checked_sub(
1918                self.realized_pnl
1919                    .unwrap_or(Money::zero(self.settlement_currency)),
1920            )
1921            .ok_or_else(|| invalid("position PnL increment overflow"))
1922    }
1923
1924    /// Calculates PnL using Decimal prices and exact quantity.
1925    ///
1926    /// # Errors
1927    ///
1928    /// Returns an error if inverse prices are invalid, arithmetic overflows, or precision is unsupported.
1929    pub fn try_calculate_pnl(
1930        &self,
1931        avg_px_open: Decimal,
1932        avg_px_close: Decimal,
1933        quantity: Quantity,
1934    ) -> CorrectnessResult<Money> {
1935        let qty = qty(quantity)?.min(self.signed_qty.abs());
1936        if qty.is_zero() {
1937            return Ok(Money::zero(self.settlement_currency));
1938        }
1939
1940        let cost = mul_rounded(avg_px_open, qty)?;
1941        let basis_cost = mul_rounded(avg_px_open, self.signed_qty.abs())?;
1942        let pnl = self.pnl_from_cost(avg_px_close, qty, cost, self.signed_qty.abs(), basis_cost)?;
1943        money(pnl, self.settlement_currency)
1944    }
1945
1946    /// Calculates PnL using Decimal prices and exact quantity.
1947    ///
1948    /// # Errors
1949    ///
1950    /// Returns an error if [`Self::try_calculate_pnl`] fails.
1951    pub fn calculate_pnl(
1952        &self,
1953        avg_px_open: Decimal,
1954        avg_px_close: Decimal,
1955        quantity: Quantity,
1956    ) -> CorrectnessResult<Money> {
1957        self.try_calculate_pnl(avg_px_open, avg_px_close, quantity)
1958    }
1959
1960    /// Returns total PnL at the given price.
1961    ///
1962    /// # Errors
1963    ///
1964    /// Returns an error if the PnL cannot be calculated or represented.
1965    pub fn try_total_pnl(&self, last: Price) -> CorrectnessResult<Money> {
1966        let unrealized = self.unrealized_decimal(last)?;
1967        let realized = self.realized_decimal()?;
1968        let total = add_pnl(realized, unrealized, self.settlement_currency)?;
1969        money(total, self.settlement_currency)
1970    }
1971
1972    /// Returns total PnL at the given price.
1973    ///
1974    /// # Errors
1975    ///
1976    /// Returns an error if [`Self::try_total_pnl`] fails.
1977    pub fn total_pnl(&self, last: Price) -> CorrectnessResult<Money> {
1978        self.try_total_pnl(last)
1979    }
1980
1981    /// Returns unrealized PnL at the given price.
1982    ///
1983    /// # Errors
1984    ///
1985    /// Returns an error if the PnL cannot be calculated or represented.
1986    pub fn try_unrealized_pnl(&self, last: Price) -> CorrectnessResult<Money> {
1987        money(self.unrealized_decimal(last)?, self.settlement_currency)
1988    }
1989
1990    fn unrealized_decimal(&self, last: Price) -> CorrectnessResult<Decimal> {
1991        if self.side == PositionSide::Flat {
1992            return Ok(Decimal::ZERO);
1993        }
1994
1995        self.pnl_from_cost(
1996            price(last)?,
1997            self.signed_qty.abs(),
1998            self.cost_open,
1999            self.signed_qty.abs(),
2000            self.cost_open,
2001        )
2002    }
2003
2004    /// Returns unrealized PnL at the given price.
2005    ///
2006    /// # Errors
2007    ///
2008    /// Returns an error if [`Self::try_unrealized_pnl`] fails.
2009    pub fn unrealized_pnl(&self, last: Price) -> CorrectnessResult<Money> {
2010        self.try_unrealized_pnl(last)
2011    }
2012
2013    /// Returns the order side required to close this position.
2014    #[must_use]
2015    pub fn closing_order_side(&self) -> Option<OrderSide> {
2016        match self.side {
2017            PositionSide::Long => Some(OrderSide::Sell),
2018            PositionSide::Short => Some(OrderSide::Buy),
2019            PositionSide::Flat => None,
2020        }
2021    }
2022
2023    /// Returns whether the given order side is opposite to the position entry side.
2024    #[must_use]
2025    pub fn is_opposite_side(&self, side: OrderSide) -> bool {
2026        self.entry != side
2027    }
2028
2029    /// Returns the instrument symbol.
2030    #[must_use]
2031    pub fn symbol(&self) -> Symbol {
2032        self.instrument_id.symbol
2033    }
2034
2035    /// Returns the trading venue.
2036    #[must_use]
2037    pub fn venue(&self) -> Venue {
2038        self.instrument_id.venue
2039    }
2040
2041    /// Returns the count of order fill events applied to this position.
2042    #[must_use]
2043    pub fn event_count(&self) -> usize {
2044        self.events.len()
2045    }
2046
2047    /// Returns unique client order IDs from all fill events, sorted.
2048    #[must_use]
2049    pub fn client_order_ids(&self) -> Vec<ClientOrderId> {
2050        // First to hash set to remove duplicate, then again iter to vector
2051        let mut result = self
2052            .events
2053            .iter()
2054            .map(|event| event.client_order_id)
2055            .collect::<AHashSet<ClientOrderId>>()
2056            .into_iter()
2057            .collect::<Vec<ClientOrderId>>();
2058        result.sort_unstable();
2059        result
2060    }
2061
2062    /// Returns unique venue order IDs from all fill events, sorted.
2063    #[must_use]
2064    pub fn venue_order_ids(&self) -> Vec<VenueOrderId> {
2065        // First to hash set to remove duplicate, then again iter to vector
2066        let mut result = self
2067            .events
2068            .iter()
2069            .map(|event| event.venue_order_id)
2070            .collect::<AHashSet<VenueOrderId>>()
2071            .into_iter()
2072            .collect::<Vec<VenueOrderId>>();
2073        result.sort_unstable();
2074        result
2075    }
2076
2077    /// Returns unique trade IDs from all fill events, sorted.
2078    #[must_use]
2079    pub fn trade_ids(&self) -> Vec<TradeId> {
2080        let mut result = self
2081            .events
2082            .iter()
2083            .map(|event| event.trade_id)
2084            .collect::<AHashSet<TradeId>>()
2085            .into_iter()
2086            .collect::<Vec<TradeId>>();
2087        result.sort_unstable();
2088        result
2089    }
2090
2091    /// Calculates the notional value based on the last price.
2092    ///
2093    /// # Errors
2094    ///
2095    /// Returns an error if this is an inverse position without a base currency, the price is not
2096    /// positive for a non-premium inverse position, or the result cannot be represented as
2097    /// [`Money`].
2098    pub fn try_notional_value(&self, last: Price) -> anyhow::Result<Money> {
2099        let currency = if self.is_inverse {
2100            self.base_currency.ok_or_else(|| {
2101                anyhow::anyhow!(
2102                    "inverse position {} has no base currency",
2103                    self.instrument_id
2104                )
2105            })?
2106        } else {
2107            self.settlement_currency
2108        };
2109
2110        notional(
2111            self.quantity,
2112            last,
2113            self.multiplier,
2114            self.instrument_class
2115                .divides_notional_by_price(self.is_inverse),
2116            currency,
2117        )
2118        .map_err(Into::into)
2119    }
2120
2121    /// Calculates the notional value based on the last price.
2122    ///
2123    /// # Panics
2124    ///
2125    /// Panics if [`Position::try_notional_value`] returns an error.
2126    #[must_use]
2127    pub fn notional_value(&self, last: Price) -> Money {
2128        self.try_notional_value(last)
2129            .expect("invalid notional value")
2130    }
2131
2132    /// Returns the last `OrderFilled` event for the position (if any after purging).
2133    #[must_use]
2134    pub fn last_event(&self) -> Option<OrderFilled> {
2135        self.events.last().cloned()
2136    }
2137
2138    /// Returns the last `TradeId` for the position (if any after purging).
2139    #[must_use]
2140    pub fn last_trade_id(&self) -> Option<TradeId> {
2141        self.events.last().map(|e| e.trade_id)
2142    }
2143
2144    /// Returns whether the position is long (positive quantity).
2145    #[must_use]
2146    pub fn is_long(&self) -> bool {
2147        self.side == PositionSide::Long
2148    }
2149
2150    /// Returns whether the position is short (negative quantity).
2151    #[must_use]
2152    pub fn is_short(&self) -> bool {
2153        self.side == PositionSide::Short
2154    }
2155
2156    /// Returns whether the position is currently open (has quantity and no close timestamp).
2157    #[must_use]
2158    pub fn is_open(&self) -> bool {
2159        self.side != PositionSide::Flat && self.ts_closed.is_none()
2160    }
2161
2162    /// Returns whether the position is closed (flat with a close timestamp).
2163    #[must_use]
2164    pub fn is_closed(&self) -> bool {
2165        self.side == PositionSide::Flat && self.ts_closed.is_some()
2166    }
2167
2168    /// Returns whether an authoritative instrument close settled the current cycle.
2169    ///
2170    /// Reads the replay history, so it is false for a copy made by
2171    /// [`Self::clone_without_events`] or [`Self::clone_for_snapshot`].
2172    #[must_use]
2173    pub fn is_settled(&self) -> bool {
2174        matches!(
2175            self.replay_events.last(),
2176            Some(PositionReplayEvent::InstrumentClosed(_))
2177        )
2178    }
2179
2180    /// Returns whether replaying the position's fills alone cannot rebuild its state.
2181    ///
2182    /// Fill voids, settlements, and price restatements change state without a new
2183    /// quantity-bearing fill, so persistence must store the complete replay state.
2184    /// Retained virtual position cycles also require the complete replay state.
2185    #[must_use]
2186    pub fn requires_replay_state(&self) -> bool {
2187        // A price restatement is stored only in replay, so equal lengths cannot contain one
2188        !self.fill_voids.is_empty()
2189            || self.is_settled()
2190            || (self.replay_events.len() > self.events.len() && self.has_replay_price_restatement())
2191            || (self.id.is_virtual() && self.replay_events.len() > self.events.len())
2192    }
2193
2194    /// Returns the signed quantity as a `Decimal`.
2195    ///
2196    /// Uses the authoritative Decimal signed quantity, as the `quantity`
2197    /// field may have reduced precision based on the instrument's `size_precision`.
2198    #[must_use]
2199    pub fn signed_decimal_qty(&self) -> Decimal {
2200        self.signed_qty
2201    }
2202
2203    /// Returns the cumulative commissions for the position as a vector.
2204    #[must_use]
2205    pub fn commissions(&self) -> Vec<Money> {
2206        self.commissions.values().copied().collect()
2207    }
2208}
2209
2210impl PartialEq<Self> for Position {
2211    fn eq(&self, other: &Self) -> bool {
2212        self.id == other.id
2213    }
2214}
2215
2216impl Eq for Position {}
2217
2218impl Hash for Position {
2219    fn hash<H: Hasher>(&self, state: &mut H) {
2220        self.id.hash(state);
2221    }
2222}
2223
2224impl Display for Position {
2225    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2226        let quantity_str = if self.quantity == Quantity::zero(self.size_precision) {
2227            String::new()
2228        } else {
2229            self.quantity.to_formatted_string() + " "
2230        };
2231
2232        write!(
2233            f,
2234            "Position({} {}{}, id={})",
2235            self.side, quantity_str, self.instrument_id, self.id
2236        )
2237    }
2238}
2239
2240fn invalid(message: &str) -> CorrectnessError {
2241    CorrectnessError::PredicateViolation {
2242        message: message.to_owned(),
2243    }
2244}
2245
2246pub(crate) fn from_raw(mut raw: i128, mut scale: u32) -> CorrectnessResult<Decimal> {
2247    if let Ok(value) = Decimal::try_from_i128_with_scale(raw, scale) {
2248        return Ok(value.normalize());
2249    }
2250
2251    while scale > 0 && raw % 10 == 0 {
2252        raw /= 10;
2253        scale -= 1;
2254    }
2255
2256    Decimal::try_from_i128_with_scale(raw, scale)
2257        .map_err(|_| invalid("position input exceeds exact Decimal representation"))
2258}
2259
2260#[allow(
2261    clippy::useless_conversion,
2262    reason = "raw integer widths vary between standard and high precision"
2263)]
2264pub(crate) fn price(value: Price) -> CorrectnessResult<Decimal> {
2265    from_raw(
2266        i128::from(value.raw),
2267        u32::from(FIXED_PRECISION.max(value.precision)),
2268    )
2269}
2270
2271#[allow(
2272    clippy::unnecessary_fallible_conversions,
2273    reason = "high precision quantities use u128 and require a checked signed conversion"
2274)]
2275pub(crate) fn qty(value: Quantity) -> CorrectnessResult<Decimal> {
2276    let raw = i128::try_from(value.raw)
2277        .map_err(|_| invalid("position quantity exceeds Decimal bounds"))?;
2278    from_raw(raw, u32::from(FIXED_PRECISION.max(value.precision)))
2279}
2280
2281#[allow(
2282    clippy::useless_conversion,
2283    reason = "raw integer widths vary between standard and high precision"
2284)]
2285pub(crate) fn amount(value: Money) -> CorrectnessResult<Decimal> {
2286    from_raw(
2287        i128::from(value.raw),
2288        u32::from(FIXED_PRECISION.max(value.currency.precision)),
2289    )
2290}
2291
2292pub(crate) fn quantity(value: Decimal, precision: u8) -> CorrectnessResult<Quantity> {
2293    let precision = precision.max(value.normalize().scale() as u8);
2294    let quantity = Quantity::from_decimal_dp(value, precision)?;
2295    if qty(quantity)? != value {
2296        return Err(invalid("position quantity loses instrument precision"));
2297    }
2298
2299    Ok(quantity)
2300}
2301
2302pub(crate) fn quantity_add(
2303    lhs: Quantity,
2304    rhs: Quantity,
2305    precision: u8,
2306) -> CorrectnessResult<Quantity> {
2307    if let Some(sum) = lhs.checked_add(rhs)
2308        && let Some(quantity) = quantity_native(sum, precision)
2309    {
2310        return Ok(quantity);
2311    }
2312
2313    quantity(add(qty(lhs)?, qty(rhs)?)?, precision)
2314}
2315
2316#[allow(clippy::useless_conversion, reason = "QuantityRaw is u64 or u128")]
2317pub(crate) fn quantity_sub(
2318    lhs: Quantity,
2319    rhs: Quantity,
2320    precision: u8,
2321) -> CorrectnessResult<Quantity> {
2322    if u128::from(lhs.raw) <= Decimal::MAX.mantissa() as u128
2323        && let Some(difference) = lhs.checked_sub(rhs)
2324        && let Some(quantity) = quantity_native(difference, precision)
2325    {
2326        return Ok(quantity);
2327    }
2328
2329    quantity(sub(qty(lhs)?, qty(rhs)?)?, precision)
2330}
2331
2332#[allow(clippy::useless_conversion, reason = "QuantityRaw is u64 or u128")]
2333fn quantity_native(value: Quantity, precision: u8) -> Option<Quantity> {
2334    if !raw_scales_match(value.precision, precision)
2335        || u128::from(value.raw) > Decimal::MAX.mantissa() as u128
2336    {
2337        return None;
2338    }
2339
2340    let step = QuantityRaw::pow(
2341        10,
2342        u32::from(FIXED_PRECISION.max(value.precision) - precision),
2343    );
2344
2345    if !value.raw.is_multiple_of(step) {
2346        return None;
2347    }
2348
2349    Quantity::from_raw_checked(value.raw, precision).ok()
2350}
2351
2352pub(crate) fn proportion(
2353    value: Decimal,
2354    numerator: Decimal,
2355    denominator: Decimal,
2356) -> CorrectnessResult<Decimal> {
2357    if denominator.is_zero() {
2358        return Err(invalid("position proportion has zero denominator"));
2359    }
2360
2361    if value.is_zero() || numerator.is_zero() {
2362        return Ok(Decimal::ZERO);
2363    }
2364
2365    if let Ok(product) = mul(value, numerator)
2366        && let Ok(result) = div(product, denominator)
2367        && sub(value, result).is_ok()
2368    {
2369        return Ok(result);
2370    }
2371
2372    let raw = U512::from(value.mantissa().unsigned_abs())
2373        * U512::from(numerator.mantissa().unsigned_abs());
2374    let divisor = U512::from(denominator.mantissa().unsigned_abs());
2375    let negative =
2376        value.is_sign_negative() ^ numerator.is_sign_negative() ^ denominator.is_sign_negative();
2377    for scale in (0..=Decimal::MAX_SCALE).rev() {
2378        let exponent = scale as i32 + denominator.scale() as i32
2379            - value.scale() as i32
2380            - numerator.scale() as i32;
2381        let ten = U512::from(10_u8);
2382        let (dividend, divisor) = if exponent >= 0 {
2383            (raw * ten.pow(U512::from(exponent as u32)), divisor)
2384        } else {
2385            (raw, divisor * ten.pow(U512::from(exponent.unsigned_abs())))
2386        };
2387
2388        let Some(result) = decimal_quotient(dividend, divisor, scale, negative) else {
2389            continue;
2390        };
2391
2392        if result.is_zero() {
2393            return Err(invalid("position proportional allocation underflow"));
2394        }
2395
2396        if sub(value, result).is_ok() {
2397            return Ok(result);
2398        }
2399    }
2400
2401    Err(invalid("position proportional allocation overflow"))
2402}
2403
2404fn decimal_quotient(dividend: U512, divisor: U512, scale: u32, negative: bool) -> Option<Decimal> {
2405    let mut quotient = dividend / divisor;
2406    let doubled = (dividend % divisor) * U512::from(2_u8);
2407    if doubled > divisor || (doubled == divisor && quotient % U512::from(2_u8) != U512::ZERO) {
2408        quotient += U512::ONE;
2409    }
2410
2411    let mantissa = u128::try_from(quotient).ok()?;
2412    let mantissa = i128::try_from(mantissa).ok()?;
2413    from_raw(if negative { -mantissa } else { mantissa }, scale).ok()
2414}
2415
2416pub(crate) fn mul_rounded(lhs: Decimal, rhs: Decimal) -> CorrectnessResult<Decimal> {
2417    let value = lhs
2418        .checked_mul(rhs)
2419        .ok_or_else(|| invalid("position proportional arithmetic overflow"))?;
2420
2421    if !lhs.is_zero() && !rhs.is_zero() && value.is_zero() {
2422        return Err(invalid("position proportional arithmetic underflow"));
2423    }
2424
2425    Ok(value.normalize())
2426}
2427
2428pub(crate) fn add(lhs: Decimal, rhs: Decimal) -> CorrectnessResult<Decimal> {
2429    let scale = lhs.scale().max(rhs.scale());
2430    let left_scale = 10_i128.pow(scale - lhs.scale());
2431    let right_scale = 10_i128.pow(scale - rhs.scale());
2432    if let Some(raw) = lhs.mantissa().checked_mul(left_scale).and_then(|left| {
2433        rhs.mantissa()
2434            .checked_mul(right_scale)
2435            .and_then(|right| left.checked_add(right))
2436    }) {
2437        return from_raw(raw, scale)
2438            .map_err(|e| invalid(&format!("position exact sum {lhs} + {rhs}: {e}")));
2439    }
2440
2441    let left = U256::from(lhs.mantissa().unsigned_abs()) * U256::from(left_scale as u128);
2442    let right = U256::from(rhs.mantissa().unsigned_abs()) * U256::from(right_scale as u128);
2443    let (raw, negative) = if lhs.is_sign_negative() == rhs.is_sign_negative() {
2444        (left + right, lhs.is_sign_negative())
2445    } else if left >= right {
2446        (left - right, lhs.is_sign_negative())
2447    } else {
2448        (right - left, rhs.is_sign_negative())
2449    };
2450
2451    from_wide(raw, scale, negative)
2452}
2453
2454pub(crate) fn add_rounded(lhs: Decimal, rhs: Decimal) -> CorrectnessResult<Decimal> {
2455    let result = lhs
2456        .checked_add(rhs)
2457        .ok_or_else(|| invalid("position Decimal addition overflow"))?;
2458
2459    if (!rhs.is_zero() && result == lhs) || (!lhs.is_zero() && result == rhs) {
2460        return Err(invalid(
2461            "position Decimal addition loses the entire increment",
2462        ));
2463    }
2464
2465    Ok(result)
2466}
2467
2468fn add_pnl(lhs: Decimal, rhs: Decimal, currency: Currency) -> CorrectnessResult<Decimal> {
2469    let result = lhs
2470        .checked_add(rhs)
2471        .ok_or_else(|| invalid("position Decimal addition overflow"))?;
2472
2473    let lost = if result == lhs {
2474        rhs
2475    } else if result == rhs {
2476        lhs
2477    } else {
2478        Decimal::ZERO
2479    };
2480
2481    if !lost.is_zero() && lost.abs() >= amount(Money::from_raw_checked(1, currency)?)? {
2482        return Err(invalid(
2483            "position PnL addition loses at least one native Money unit",
2484        ));
2485    }
2486
2487    Ok(result)
2488}
2489
2490pub(crate) fn sub(lhs: Decimal, rhs: Decimal) -> CorrectnessResult<Decimal> {
2491    add(lhs, -rhs)
2492}
2493
2494pub(crate) fn mul(lhs: Decimal, rhs: Decimal) -> CorrectnessResult<Decimal> {
2495    let scale = lhs.scale() + rhs.scale();
2496    if let Some(raw) = lhs.mantissa().checked_mul(rhs.mantissa()) {
2497        return from_raw(raw, scale);
2498    }
2499
2500    let raw = U256::from(lhs.mantissa().unsigned_abs()) * U256::from(rhs.mantissa().unsigned_abs());
2501    from_wide(raw, scale, lhs.is_sign_negative() != rhs.is_sign_negative())
2502}
2503
2504fn from_wide(mut raw: U256, mut scale: u32, negative: bool) -> CorrectnessResult<Decimal> {
2505    let ten = U256::from(10_u8);
2506    while scale > 0 && raw % ten == U256::ZERO {
2507        raw /= ten;
2508        scale -= 1;
2509    }
2510
2511    let raw: u128 = raw
2512        .try_into()
2513        .map_err(|_| invalid("position Decimal arithmetic overflow"))?;
2514    let signed =
2515        i128::try_from(raw).map_err(|_| invalid("position Decimal arithmetic overflow"))?;
2516    from_raw(if negative { -signed } else { signed }, scale)
2517}
2518
2519pub(crate) fn div(lhs: Decimal, rhs: Decimal) -> CorrectnessResult<Decimal> {
2520    let value = lhs
2521        .checked_div(rhs)
2522        .ok_or_else(|| invalid("position Decimal division overflow or zero divisor"))?;
2523
2524    if !lhs.is_zero() && value.is_zero() {
2525        return Err(invalid("position Decimal division underflow"));
2526    }
2527
2528    Ok(value)
2529}
2530
2531pub(crate) fn money(amount: Decimal, currency: Currency) -> CorrectnessResult<Money> {
2532    Money::from_decimal_native(amount, currency)
2533}
2534
2535#[allow(
2536    clippy::useless_conversion,
2537    reason = "the raw width differs when high-precision is disabled"
2538)]
2539pub(crate) fn money_from_qty(value: Quantity, currency: Currency) -> CorrectnessResult<Money> {
2540    if raw_scales_match(value.precision, currency.precision)
2541        && u128::from(value.raw) <= Decimal::MAX.mantissa() as u128
2542        && let Ok(raw) = value.raw.try_into()
2543    {
2544        return Money::from_raw_checked(raw, currency);
2545    }
2546
2547    money(qty(value)?, currency)
2548}
2549
2550pub(crate) fn notional(
2551    quantity: Quantity,
2552    last: Price,
2553    multiplier: Quantity,
2554    divides_by_price: bool,
2555    currency: Currency,
2556) -> CorrectnessResult<Money> {
2557    let product = mul_rounded(qty(quantity)?, qty(multiplier)?)?;
2558    let price = price(last)?;
2559    let amount = if divides_by_price {
2560        if price <= Decimal::ZERO {
2561            return Err(invalid(
2562                "price must be positive for inverse notional valuation",
2563            ));
2564        }
2565
2566        div(product, price)?
2567    } else {
2568        mul_rounded(product, price)?
2569    };
2570
2571    money(amount, currency)
2572}
2573
2574#[allow(
2575    clippy::useless_conversion,
2576    clippy::unnecessary_fallible_conversions,
2577    reason = "raw integer widths vary between standard and high precision"
2578)]
2579pub(crate) fn split_commission_qty(
2580    commission: Money,
2581    closing_qty: Quantity,
2582    total_qty: Quantity,
2583) -> CorrectnessResult<(Money, Money)> {
2584    if closing_qty.non_zero()
2585        && closing_qty < total_qty
2586        && raw_scales_match(closing_qty.precision, total_qty.precision)
2587        && u128::from(total_qty.raw) <= Decimal::MAX.mantissa() as u128
2588        && let Some(magnitude) = checked_mul_div_raw(
2589            commission.raw.unsigned_abs(),
2590            closing_qty.raw,
2591            total_qty.raw,
2592        )
2593    {
2594        let raw = i128::try_from(magnitude)
2595            .map_err(|_| invalid("commission split exceeds raw bounds"))?;
2596        return commission_parts(
2597            commission,
2598            if commission.is_negative() { -raw } else { raw },
2599        );
2600    }
2601
2602    split_commission(commission, qty(closing_qty)?, qty(total_qty)?)
2603}
2604
2605#[allow(
2606    clippy::useless_conversion,
2607    reason = "raw integer widths vary between standard and high precision"
2608)]
2609pub(crate) fn split_commission(
2610    commission: Money,
2611    closing_qty: Decimal,
2612    total_qty: Decimal,
2613) -> CorrectnessResult<(Money, Money)> {
2614    if closing_qty <= Decimal::ZERO || closing_qty >= total_qty {
2615        return Err(invalid(
2616            "commission split requires a positive closing quantity below the total",
2617        ));
2618    }
2619
2620    let raw = i128::from(commission.raw);
2621    let mut numerator =
2622        U512::from(raw.unsigned_abs()) * U512::from(closing_qty.mantissa().unsigned_abs());
2623    let mut denominator = U512::from(total_qty.mantissa().unsigned_abs());
2624    let ten = U512::from(10_u8);
2625    if total_qty.scale() >= closing_qty.scale() {
2626        numerator *= ten.pow(U512::from(total_qty.scale() - closing_qty.scale()));
2627    } else {
2628        denominator *= ten.pow(U512::from(closing_qty.scale() - total_qty.scale()));
2629    }
2630
2631    let magnitude: u128 = (numerator / denominator)
2632        .try_into()
2633        .map_err(|_| invalid("commission split exceeds raw bounds"))?;
2634    let magnitude =
2635        i128::try_from(magnitude).map_err(|_| invalid("commission split exceeds raw bounds"))?;
2636    commission_parts(commission, if raw < 0 { -magnitude } else { magnitude })
2637}
2638
2639#[allow(clippy::useless_conversion, reason = "MoneyRaw is i64 or i128")]
2640fn commission_parts(commission: Money, closing_raw: i128) -> CorrectnessResult<(Money, Money)> {
2641    let closing_raw = closing_raw
2642        .try_into()
2643        .map_err(|_| invalid("commission split exceeds native Money bounds"))?;
2644    let closing = Money::from_raw(closing_raw, commission.currency);
2645    let opening = commission
2646        .checked_sub(closing)
2647        .ok_or_else(|| invalid("position commission allocation overflow"))?;
2648    Ok((closing, opening))
2649}
2650
2651/// Replays position legs onto a hypothetical NETTING position in `ts_opened`
2652/// order, returning `(net_signed_qty, net_avg_px_open)`.
2653///
2654/// Each leg is `(signed_qty, avg_px_open, ts_opened_ns)`. Rules follow
2655/// [`Position::apply`]:
2656/// - Same-side legs produce a quantity-weighted average open price.
2657/// - Opposite-side legs partial-close at the existing average.
2658/// - A leg that crosses zero makes the residual take that leg's price.
2659///
2660/// Zero-quantity legs are skipped. Sort is stable on `ts_opened`; the caller
2661/// orders ties (e.g. by `position_id`).
2662#[must_use]
2663pub fn fold_net_position(legs: &[(Decimal, Decimal, u64)]) -> (Decimal, Decimal) {
2664    let mut sorted: Vec<&(Decimal, Decimal, u64)> =
2665        legs.iter().filter(|(qty, _, _)| !qty.is_zero()).collect();
2666    sorted.sort_by_key(|(_, _, ts_opened)| *ts_opened);
2667
2668    let mut net_signed_qty = Decimal::ZERO;
2669    let mut net_avg_px = Decimal::ZERO;
2670
2671    for &(p_qty, p_px, _) in sorted {
2672        if net_signed_qty.is_zero() {
2673            net_signed_qty = p_qty;
2674            net_avg_px = p_px;
2675            continue;
2676        }
2677
2678        let same_side = net_signed_qty.is_sign_negative() == p_qty.is_sign_negative();
2679        let new_net = net_signed_qty + p_qty;
2680        if same_side {
2681            let total_abs = net_signed_qty.abs() + p_qty.abs();
2682            net_avg_px = (net_signed_qty.abs() * net_avg_px + p_qty.abs() * p_px) / total_abs;
2683            net_signed_qty = new_net;
2684        } else if new_net.is_zero()
2685            || new_net.is_sign_negative() == net_signed_qty.is_sign_negative()
2686        {
2687            net_signed_qty = new_net;
2688            if new_net.is_zero() {
2689                net_avg_px = Decimal::ZERO;
2690            }
2691        } else {
2692            net_signed_qty = new_net;
2693            net_avg_px = p_px;
2694        }
2695    }
2696
2697    (net_signed_qty, net_avg_px)
2698}
2699
2700#[cfg(test)]
2701mod tests {
2702    use std::str::FromStr;
2703
2704    use ahash::AHashSet;
2705    use nautilus_core::{DurationNanos, UUID4, UnixNanos, correctness::CorrectnessError};
2706    use proptest::prelude::*;
2707    use rstest::rstest;
2708    use rust_decimal::{Decimal, prelude::ToPrimitive};
2709    use rust_decimal_macros::dec;
2710
2711    use super::*;
2712    #[cfg(feature = "defi")]
2713    use crate::enums::CurrencyType;
2714    use crate::{
2715        data::InstrumentClose,
2716        enums::{InstrumentCloseType, OrderSide, OrderType, PositionAdjustmentType, PositionSide},
2717        events::{
2718            OrderEventAny, OrderFillVoided, OrderFilled, PositionAdjusted, PositionSnapshot,
2719            order::spec::{OrderFillVoidedSpec, OrderFilledSpec},
2720        },
2721        identifiers::{
2722            AccountId, ClientOrderId, InstrumentId, PositionId, StrategyId, TradeId, VenueOrderId,
2723            stubs::uuid4,
2724        },
2725        instruments::{
2726            BinaryOption, CryptoFuture, CryptoOption, CryptoPerpetual, CurrencyPair, Instrument,
2727            InstrumentAny, stubs::*,
2728        },
2729        orders::{Order, builder::OrderTestBuilder, stubs::TestOrderEventStubs},
2730        stubs::*,
2731        types::{
2732            Currency, Money, Price, Quantity,
2733            money::{MONEY_RAW_MAX, MoneyRaw},
2734        },
2735    };
2736
2737    fn native_money(value: Decimal, currency: Currency) -> Money {
2738        let value = value.round_dp_with_strategy(
2739            u32::from(crate::types::fixed::FIXED_PRECISION),
2740            rust_decimal::RoundingStrategy::MidpointNearestEven,
2741        );
2742        Money::from_decimal_exact(value, currency).unwrap()
2743    }
2744
2745    #[rstest]
2746    fn test_decimal_intermediate_price_restatement_after_third_reduction(audusd_sim: CurrencyPair) {
2747        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
2748        let opening = OrderFilledSpec::builder()
2749            .instrument_id(instrument.id())
2750            .position_id(PositionId::from("P-THIRD-RESTATE"))
2751            .last_qty(Quantity::from(100_000))
2752            .last_px(Price::from("1.00001"))
2753            .commission(Money::zero(Currency::USD()))
2754            .build();
2755        let mut position = Position::new(&instrument, opening.clone());
2756        let mut addition = opening.clone();
2757        addition.trade_id = TradeId::from("T-ADD");
2758        addition.event_id = UUID4::new();
2759        addition.last_qty = Quantity::from(200_000);
2760        addition.last_px = Price::from("1.00002");
2761        position.try_apply(&addition).unwrap();
2762        let mut reduction = opening.clone();
2763        reduction.trade_id = TradeId::from("T-REDUCE");
2764        reduction.event_id = UUID4::new();
2765        reduction.order_side = OrderSide::Sell;
2766        reduction.last_px = Price::from("1.00004");
2767        position.try_apply(&reduction).unwrap();
2768        let realized_before = position.realized_pnl;
2769        let mut restatement = opening;
2770        restatement.event_id = UUID4::new();
2771        restatement.last_px = Price::from("1.00003");
2772
2773        position.try_apply(&restatement).unwrap();
2774
2775        assert_eq!(position.quantity, Quantity::from(200_000));
2776        assert_eq!(position.signed_qty, dec!(200000));
2777        assert_eq!(position.cost_open, dec!(200004.66666666666666666666666));
2778        assert_eq!(position.avg_px_open, dec!(1.0000233333333333333333333333));
2779        assert_eq!(position.realized_pnl, realized_before);
2780        assert_eq!(position.events.len(), 3);
2781        assert_eq!(position.replay_events.len(), 4);
2782    }
2783
2784    #[rstest]
2785    #[case(OrderSide::Buy, dec!(1))]
2786    #[case(OrderSide::Sell, dec!(-1))]
2787    fn test_decimal_intermediate_inverse_large_move(
2788        btcusd_bybit: CryptoPerpetual,
2789        #[case] side: OrderSide,
2790        #[case] sign: Decimal,
2791    ) {
2792        let instrument = InstrumentAny::CryptoPerpetual(btcusd_bybit);
2793        let opening = OrderFilledSpec::builder()
2794            .instrument_id(instrument.id())
2795            .position_id(PositionId::from("P-INVERSE-MOVE"))
2796            .order_side(side)
2797            .last_qty(Quantity::from(1))
2798            .last_px(Price::from("0.0625"))
2799            .commission(Money::zero(Currency::BTC()))
2800            .build();
2801        let mut position = Position::new(&instrument, opening.clone());
2802        let mut settled = position.clone();
2803        let mark = Price::from("0.15");
2804        let expected = native_money(sign * dec!(28) / dec!(3), Currency::BTC());
2805        let unrealized = position.try_unrealized_pnl(mark).unwrap();
2806        let realized = position.try_realized_pnl(mark, position.quantity).unwrap();
2807        let mut closing = opening;
2808        closing.trade_id = TradeId::from("T-CLOSE");
2809        closing.event_id = UUID4::new();
2810
2811        closing.order_side = if side == OrderSide::Buy {
2812            OrderSide::Sell
2813        } else {
2814            OrderSide::Buy
2815        };
2816
2817        closing.last_px = mark;
2818        position.try_apply(&closing).unwrap();
2819        let close = contract_expired(&instrument, "0.15");
2820        settled.apply_instrument_close(close).unwrap();
2821
2822        assert_eq!(unrealized, expected);
2823        assert_eq!(realized, expected);
2824        assert_eq!(position.realized_pnl, Some(expected));
2825        assert_eq!(settled.realized_pnl, Some(expected));
2826        assert_eq!(position.quantity, Quantity::from(0));
2827        assert_eq!(settled.quantity, Quantity::from(0));
2828        assert_eq!(position.side, PositionSide::Flat);
2829        assert!(settled.is_settled());
2830    }
2831
2832    #[rstest]
2833    fn test_position_accepts_pnl_after_break_even_residual(audusd_sim: CurrencyPair) {
2834        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
2835        let opening = OrderFilledSpec::builder()
2836            .instrument_id(instrument.id())
2837            .position_id(PositionId::from("P-BREAK-EVEN"))
2838            .last_qty(Quantity::from(5))
2839            .last_px(Price::from("1.00000"))
2840            .commission(Money::zero(Currency::USD()))
2841            .build();
2842        let mut position = Position::new(&instrument, opening.clone());
2843
2844        for (trade_id, side, qty, px) in [
2845            ("T-ADD", OrderSide::Buy, 10, "0.60000"),
2846            ("T-REDUCE-1", OrderSide::Sell, 1, "0.70000"),
2847            ("T-REDUCE-2", OrderSide::Sell, 5, "0.74000"),
2848        ] {
2849            let fill = OrderFilled {
2850                trade_id: TradeId::from(trade_id),
2851                order_side: side,
2852                last_qty: Quantity::from(qty),
2853                last_px: Price::from(px),
2854                event_id: UUID4::new(),
2855                ..opening.clone()
2856            };
2857
2858            position.try_apply(&fill).unwrap();
2859        }
2860
2861        assert_eq!(position.realized_pnl, Some(Money::zero(Currency::USD())));
2862        assert_eq!(
2863            position.realized_pnl_remainder,
2864            dec!(0.0000000000000000000000000002)
2865        );
2866
2867        let closing = OrderFilled {
2868            trade_id: TradeId::from("T-CLOSE"),
2869            order_side: OrderSide::Sell,
2870            last_qty: Quantity::from(9),
2871            last_px: Price::from("2.00000"),
2872            event_id: UUID4::new(),
2873            ..opening
2874        };
2875
2876        let realized = position.try_realized_pnl(closing.last_px, closing.last_qty);
2877        let total = position.try_total_pnl(closing.last_px);
2878        let expected = Money::from("11.40 USD");
2879        let mut adjusted = position.clone();
2880
2881        let adjustment = PositionAdjusted::new(
2882            position.trader_id,
2883            position.strategy_id,
2884            position.instrument_id,
2885            position.id,
2886            position.account_id,
2887            PositionAdjustmentType::Funding,
2888            None,
2889            Some(expected),
2890            None,
2891            UUID4::new(),
2892            position.ts_last,
2893            position.ts_last,
2894        );
2895        let adjustment = adjusted
2896            .apply_adjustment(adjustment)
2897            .map(|()| adjusted.realized_pnl.unwrap());
2898        let closed = position
2899            .try_apply(&closing)
2900            .map(|()| position.realized_pnl.unwrap());
2901        let results: Vec<_> = [realized, total, adjustment, closed]
2902            .into_iter()
2903            .map(|result| result.map_err(|e| e.to_string()))
2904            .collect();
2905
2906        assert_eq!(results, vec![Ok(expected); 4]);
2907        assert_eq!(position.side, PositionSide::Flat);
2908        assert_eq!(position.quantity, Quantity::from(0));
2909        assert_eq!(position.cost_open, Decimal::ZERO);
2910        assert_eq!(position.realized_pnl_remainder, Decimal::ZERO);
2911        assert_eq!(adjusted.quantity, Quantity::from(9));
2912        assert_eq!(adjusted.realized_pnl_remainder, Decimal::ZERO);
2913    }
2914
2915    #[rstest]
2916    #[case::without_fee("0 USD", "10.60 USD")]
2917    #[case::with_fee("0.01 USD", "10.59 USD")]
2918    fn test_position_accepts_residual_pnl_on_close(
2919        audusd_sim: CurrencyPair,
2920        #[case] commission: &str,
2921        #[case] expected: &str,
2922    ) {
2923        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
2924        let opening = OrderFilledSpec::builder()
2925            .instrument_id(instrument.id())
2926            .position_id(PositionId::from("P-RESIDUAL-CLOSE"))
2927            .last_qty(Quantity::from(5))
2928            .last_px(Price::from("1.00000"))
2929            .commission(Money::zero(Currency::USD()))
2930            .build();
2931        let mut position = Position::new(&instrument, opening.clone());
2932
2933        for (trade_id, side, qty, px) in [
2934            ("T-ADD", OrderSide::Buy, 10, "0.60000"),
2935            ("T-REDUCE-1", OrderSide::Sell, 1, "10.00000"),
2936            ("T-REDUCE-2", OrderSide::Sell, 5, "1.00000"),
2937            ("T-ADD-2", OrderSide::Buy, 1, "0.60000"),
2938        ] {
2939            let fill = OrderFilled {
2940                trade_id: TradeId::from(trade_id),
2941                order_side: side,
2942                last_qty: Quantity::from(qty),
2943                last_px: Price::from(px),
2944                event_id: UUID4::new(),
2945                ..opening.clone()
2946            };
2947
2948            position.try_apply(&fill).unwrap();
2949        }
2950
2951        let closing = OrderFilled {
2952            trade_id: TradeId::from("T-CLOSE"),
2953            order_side: OrderSide::Sell,
2954            last_qty: Quantity::from(10),
2955            last_px: Price::from("0.72000"),
2956            commission: Some(Money::from(commission)),
2957            event_id: UUID4::new(),
2958            ..opening
2959        };
2960
2961        let realized = position.try_realized_pnl(closing.last_px, closing.last_qty);
2962        let total = position.try_total_pnl(closing.last_px);
2963        let closed = position.try_apply(&closing);
2964
2965        assert_eq!(realized.unwrap(), Money::zero(Currency::USD()));
2966        assert_eq!(total.unwrap(), Money::from("10.60 USD"));
2967        closed.unwrap();
2968        assert_eq!(position.realized_pnl, Some(Money::from(expected)));
2969        assert_eq!(position.side, PositionSide::Flat);
2970        assert_eq!(position.quantity, Quantity::from(0));
2971        assert_eq!(position.cost_open, Decimal::ZERO);
2972        assert_eq!(position.realized_pnl_remainder, Decimal::ZERO);
2973    }
2974
2975    #[rstest]
2976    fn test_decimal_intermediate_restatement_after_two_reductions(audusd_sim: CurrencyPair) {
2977        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
2978        let opening = OrderFilledSpec::builder()
2979            .instrument_id(instrument.id())
2980            .position_id(PositionId::from("P-REDUCED-LOTS"))
2981            .last_qty(Quantity::from("2.00"))
2982            .last_px(Price::from("12.00"))
2983            .commission(Money::zero(Currency::USD()))
2984            .build();
2985        let mut position = Position::new(&instrument, opening.clone());
2986        for (id, side, qty, price) in [
2987            ("T-ADD", OrderSide::Buy, "100.00", "10.00"),
2988            ("T-REDUCE-1", OrderSide::Sell, "3.00", "15.00"),
2989            ("T-REDUCE-2", OrderSide::Sell, "1.00", "15.00"),
2990        ] {
2991            let mut fill = opening.clone();
2992            fill.trade_id = TradeId::from(id);
2993            fill.event_id = UUID4::new();
2994            fill.order_side = side;
2995            fill.last_qty = Quantity::from(qty);
2996            fill.last_px = Price::from(price);
2997            position.try_apply(&fill).unwrap();
2998        }
2999
3000        let realized = position.realized_pnl;
3001        let mut restatement = opening;
3002        restatement.event_id = UUID4::new();
3003        restatement.last_px = Price::from("14.00");
3004
3005        position.try_apply(&restatement).unwrap();
3006
3007        assert_eq!(position.quantity, Quantity::from(98));
3008        assert_eq!(position.cost_open, dec!(987.686274509803921568627451));
3009        assert_eq!(position.avg_px_open, dec!(10.078431372549019607843137255));
3010        assert_eq!(position.realized_pnl, realized);
3011        assert_eq!(position.events.len(), 4);
3012        assert_eq!(position.replay_events.len(), 5);
3013    }
3014
3015    #[rstest]
3016    fn test_decimal_intermediate_adjustment_on_flat_position(audusd_sim: CurrencyPair) {
3017        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3018        let opening = OrderFilledSpec::builder()
3019            .instrument_id(instrument.id())
3020            .position_id(PositionId::from("P-ADJUST-REOPEN"))
3021            .last_qty(Quantity::from(100_000))
3022            .last_px(Price::from("1.00001"))
3023            .commission(Money::zero(Currency::USD()))
3024            .build();
3025        let mut position = Position::new(&instrument, opening);
3026        let mut addition = position.events[0].clone();
3027        addition.trade_id = TradeId::from("T-ADD-REOPEN");
3028        addition.event_id = UUID4::new();
3029        addition.last_qty = Quantity::from(23_457);
3030        addition.last_px = Price::from("1.00004");
3031        position.try_apply(&addition).unwrap();
3032        let qty = position.quantity;
3033        let average = position.avg_px_open;
3034        let mut closing = addition;
3035        closing.trade_id = TradeId::from("T-CLOSE-REOPEN");
3036        closing.event_id = UUID4::new();
3037        closing.order_side = OrderSide::Sell;
3038        closing.last_qty = qty;
3039        position.try_apply(&closing).unwrap();
3040
3041        let adjustment = PositionAdjusted::new(
3042            position.trader_id,
3043            position.strategy_id,
3044            position.instrument_id,
3045            position.id,
3046            position.account_id,
3047            PositionAdjustmentType::Commission,
3048            Some(qty.as_decimal()),
3049            None,
3050            None,
3051            UUID4::new(),
3052            position.ts_last,
3053            position.ts_last,
3054        );
3055
3056        position.apply_adjustment(adjustment).unwrap();
3057
3058        assert_eq!(position.quantity, qty);
3059        assert_eq!(position.signed_qty, dec!(123457));
3060        assert_eq!(position.side, PositionSide::Long);
3061        assert_eq!(position.avg_px_open, average);
3062        assert_eq!(position.cost_open, dec!(123458.93828));
3063    }
3064
3065    #[cfg(feature = "high-precision")]
3066    #[rstest]
3067    #[case(OrderSide::Buy)]
3068    #[case(OrderSide::Sell)]
3069    fn test_position_accepts_rounded_dex_fill_cost(
3070        audusd_sim: CurrencyPair,
3071        #[case] side: OrderSide,
3072    ) {
3073        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3074        let opening = OrderFilledSpec::builder()
3075            .instrument_id(instrument.id())
3076            .position_id(PositionId::from("P-DEX-COST"))
3077            .order_side(side)
3078            .last_qty(Quantity::from("0.0010000004030790"))
3079            .last_px(Price::from("1891.3472376376468003"))
3080            .commission(Money::zero(Currency::USD()))
3081            .build();
3082        let mut position = Position::new_checked(&instrument, opening.clone()).unwrap();
3083        let expected_cost = dec!(1.8913480000000000000450346181);
3084        let notional = position.try_notional_value(opening.last_px).unwrap();
3085        let opening_cost = position.cost_open;
3086        let mut addition = opening.clone();
3087        addition.trade_id = TradeId::from("T-DEX-ADD");
3088        addition.event_id = UUID4::new();
3089        position.try_apply(&addition).unwrap();
3090        let added_cost = position.cost_open;
3091        let mut settled = position.clone();
3092        let mut closing = opening;
3093        closing.trade_id = TradeId::from("T-DEX-REDUCE");
3094        closing.event_id = UUID4::new();
3095
3096        closing.order_side = if side == OrderSide::Buy {
3097            OrderSide::Sell
3098        } else {
3099            OrderSide::Buy
3100        };
3101
3102        position.try_apply(&closing).unwrap();
3103        let remaining_cost = position.cost_open;
3104        closing.trade_id = TradeId::from("T-DEX-CLOSE");
3105        closing.event_id = UUID4::new();
3106        position.try_apply(&closing).unwrap();
3107        let close = contract_expired(&instrument, "1891.3472376376468003");
3108        settled.apply_instrument_close(close).unwrap();
3109
3110        assert_eq!(opening_cost, expected_cost);
3111        assert_eq!(notional.as_decimal(), dec!(1.891348));
3112        assert_eq!(added_cost, dec!(3.7826960000000000000900692362));
3113        assert_eq!(remaining_cost, expected_cost);
3114        assert_eq!(position.cost_open, Decimal::ZERO);
3115        assert_eq!(position.cost_close, added_cost);
3116        assert_eq!(position.signed_qty, Decimal::ZERO);
3117        assert_eq!(position.realized_pnl, Some(Money::zero(Currency::USD())));
3118        assert_eq!(position.realized_pnl_remainder, Decimal::ZERO);
3119        assert_eq!(settled.cost_open, Decimal::ZERO);
3120        assert_eq!(settled.cost_close, added_cost);
3121        assert_eq!(settled.signed_qty, Decimal::ZERO);
3122        assert_eq!(settled.realized_pnl, position.realized_pnl);
3123        assert_eq!(settled.realized_pnl_remainder, Decimal::ZERO);
3124    }
3125
3126    #[rstest]
3127    fn test_decimal_intermediate_pnl_accepts_repeating_average(audusd_sim: CurrencyPair) {
3128        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3129        let opening = OrderFilledSpec::builder()
3130            .instrument_id(instrument.id())
3131            .position_id(PositionId::from("P-REPEATING-PNL"))
3132            .last_qty(Quantity::from(100_000))
3133            .last_px(Price::from("1.00001"))
3134            .commission(Money::zero(Currency::USD()))
3135            .build();
3136        let mut position = Position::new(&instrument, opening.clone());
3137        let mut addition = opening;
3138        addition.trade_id = TradeId::from("T-ADD");
3139        addition.event_id = UUID4::new();
3140        addition.last_qty = Quantity::from(23_457);
3141        addition.last_px = Price::from("1.00004");
3142        position.try_apply(&addition).unwrap();
3143
3144        let pnl = position.calculate_pnl(position.avg_px_open, dec!(1.00005), position.quantity);
3145        let unchanged = position.calculate_pnl(
3146            position.avg_px_open,
3147            position.avg_px_open,
3148            position.quantity,
3149        );
3150
3151        assert_eq!(position.avg_px_open, dec!(1.0000157000413099297731193857));
3152        assert_eq!(
3153            pnl.unwrap(),
3154            Money::from_decimal_exact(dec!(4.23457), Currency::USD()).unwrap()
3155        );
3156        assert_eq!(unchanged.unwrap(), Money::zero(Currency::USD()));
3157    }
3158
3159    #[rstest]
3160    #[case(OrderSide::Buy, "0.1234", "0.1235")]
3161    #[case(OrderSide::Sell, "0.1235", "0.1234")]
3162    fn test_position_preserves_micro_fees_and_profit(
3163        audusd_sim: CurrencyPair,
3164        #[case] side: OrderSide,
3165        #[case] opening_px: &str,
3166        #[case] closing_px: &str,
3167    ) {
3168        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3169        let opening = OrderFilledSpec::builder()
3170            .instrument_id(instrument.id())
3171            .position_id(PositionId::from("P-MICRO"))
3172            .order_side(side)
3173            .last_qty(Quantity::from("0.01"))
3174            .last_px(Price::from(opening_px))
3175            .commission(Money::from_decimal_exact(dec!(0.000001), Currency::USD()).unwrap())
3176            .build();
3177        let mut position = Position::new_checked(&instrument, opening.clone()).unwrap();
3178        assert_eq!(position.realized_pnl.unwrap().as_decimal(), dec!(-0.000001));
3179
3180        let closing = OrderFilledSpec::builder()
3181            .instrument_id(instrument.id())
3182            .position_id(position.id)
3183            .client_order_id(ClientOrderId::from("O-CLOSE-MICRO"))
3184            .trade_id(TradeId::from("T-CLOSE-MICRO"))
3185            .order_side(if side == OrderSide::Buy {
3186                OrderSide::Sell
3187            } else {
3188                OrderSide::Buy
3189            })
3190            .last_qty(Quantity::from("0.01"))
3191            .last_px(Price::from(closing_px))
3192            .commission(Money::zero(Currency::USD()))
3193            .build();
3194
3195        let mut zero_fee = opening;
3196        zero_fee.commission = Some(Money::zero(Currency::USD()));
3197        let mut without_fee = Position::new_checked(&instrument, zero_fee).unwrap();
3198        without_fee.try_apply(&closing).unwrap();
3199        position.try_apply(&closing).unwrap();
3200        assert_eq!(
3201            without_fee.realized_pnl.unwrap().as_decimal(),
3202            dec!(0.000001)
3203        );
3204        assert_eq!(position.realized_pnl.unwrap().as_decimal(), Decimal::ZERO);
3205        assert_eq!(position.signed_qty, Decimal::ZERO);
3206        assert_eq!(
3207            position.commissions(),
3208            vec![Money::from_decimal_exact(dec!(0.000001), Currency::USD()).unwrap()]
3209        );
3210    }
3211
3212    #[rstest]
3213    fn test_position_commission_overflow_preserves_all_state(audusd_sim: CurrencyPair) {
3214        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3215        let opening = OrderFilledSpec::builder()
3216            .instrument_id(instrument.id())
3217            .position_id(PositionId::from("P-OVERFLOW"))
3218            .order_side(OrderSide::Buy)
3219            .last_qty(Quantity::from(1))
3220            .last_px(Price::from("1"))
3221            .commission(Money::from_raw(
3222                crate::types::money::MONEY_RAW_MAX,
3223                Currency::USD(),
3224            ))
3225            .build();
3226        let mut position = Position::new_checked(&instrument, opening.clone()).unwrap();
3227        let before = serde_json::to_value(&position).unwrap();
3228        let mut next = opening;
3229        next.event_id = UUID4::new();
3230        next.trade_id = TradeId::from("T-OVERFLOW");
3231        next.last_qty = Quantity::from(2);
3232        next.last_px = Price::from("3");
3233        next.commission = Some(Money::from_decimal_exact(dec!(0.000001), Currency::USD()).unwrap());
3234        let result = position.try_apply(&next);
3235        assert_eq!(
3236            result.unwrap_err().to_string(),
3237            "position commission overflow"
3238        );
3239        assert_eq!(serde_json::to_value(&position).unwrap(), before);
3240    }
3241
3242    #[rstest]
3243    fn test_position_restoration_preserves_basis_and_fractional_pnl(audusd_sim: CurrencyPair) {
3244        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3245        let mut fill = OrderFilledSpec::builder()
3246            .instrument_id(instrument.id())
3247            .position_id(PositionId::from("P-RESTORE"))
3248            .order_side(OrderSide::Buy)
3249            .last_qty(Quantity::from(3))
3250            .last_px(Price::from("0.1"))
3251            .commission(Money::zero(Currency::USD()))
3252            .build();
3253        let mut position = Position::new_checked(&instrument, fill.clone()).unwrap();
3254        fill.event_id = UUID4::new();
3255        fill.trade_id = TradeId::from("T-ADD");
3256        fill.last_qty = Quantity::from(4);
3257        fill.last_px = Price::from("0.2");
3258        position.try_apply(&fill).unwrap();
3259        fill.event_id = UUID4::new();
3260        fill.trade_id = TradeId::from("T-REDUCE");
3261        fill.order_side = OrderSide::Sell;
3262        fill.last_qty = Quantity::from(1);
3263        fill.last_px = Price::from("0.3");
3264        position.try_apply(&fill).unwrap();
3265        let encoded = serde_json::to_string(&position).unwrap();
3266        let mut restored: Position = serde_json::from_str(&encoded).unwrap();
3267        fill.event_id = UUID4::new();
3268        fill.trade_id = TradeId::from("T-CLOSE");
3269        fill.last_qty = Quantity::from(6);
3270        position.try_apply(&fill).unwrap();
3271        restored.try_apply(&fill).unwrap();
3272        assert_eq!(position.realized_pnl.unwrap().as_decimal(), dec!(1));
3273        assert_eq!(position.cost_open, Decimal::ZERO);
3274        assert_eq!(position.realized_pnl_remainder, Decimal::ZERO);
3275        assert_eq!(
3276            serde_json::to_value(restored).unwrap(),
3277            serde_json::to_value(position).unwrap()
3278        );
3279    }
3280
3281    #[rstest]
3282    fn test_same_trade_id_new_price_restates_position_average(audusd_sim: CurrencyPair) {
3283        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3284        let position_id = PositionId::from("P-RESTATE");
3285        let trade_id = TradeId::from("T-1");
3286        let opening = OrderFilledSpec::builder()
3287            .instrument_id(instrument.id())
3288            .trade_id(trade_id)
3289            .order_side(OrderSide::Buy)
3290            .last_qty(Quantity::from(2))
3291            .last_px(Price::from("12"))
3292            .position_id(position_id)
3293            .build();
3294        let restatement = OrderFilledSpec::builder()
3295            .instrument_id(instrument.id())
3296            .trade_id(trade_id)
3297            .order_side(OrderSide::Buy)
3298            .last_qty(Quantity::from(2))
3299            .last_px(Price::from("9.47"))
3300            .position_id(position_id)
3301            .event_id(UUID4::new())
3302            .build();
3303        let mut position = Position::new(&instrument, opening);
3304        position.apply(&restatement);
3305
3306        assert_eq!(position.quantity.as_decimal(), Decimal::from(2));
3307        assert_eq!(position.side, PositionSide::Long);
3308        assert_eq!(position.avg_px_open, Price::from("9.47").as_decimal());
3309        assert_eq!(position.events[0].last_px, Price::from("12"));
3310
3311        let voided = OrderFillVoidedSpec::builder()
3312            .instrument_id(instrument.id())
3313            .trade_id(trade_id)
3314            .voided_qty(Quantity::from(1))
3315            .last_px(Price::from("12"))
3316            .order_side(OrderSide::Buy)
3317            .position_id(position_id)
3318            .build();
3319        position
3320            .apply_fill_void(voided, Quantity::from(1), None)
3321            .unwrap();
3322
3323        assert_eq!(position.quantity.as_decimal(), Decimal::from(1));
3324        assert_eq!(position.avg_px_open, Price::from("9.47").as_decimal());
3325        assert_eq!(position.events[0].last_px, Price::from("12"));
3326        assert!(position.requires_replay_state());
3327    }
3328
3329    #[rstest]
3330    fn test_price_restatement_of_closing_fill_keeps_open_average(audusd_sim: CurrencyPair) {
3331        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3332        let position_id = PositionId::from("P-CLOSE-RESTATE");
3333        let opening = OrderFilledSpec::builder()
3334            .instrument_id(instrument.id())
3335            .trade_id(TradeId::from("T-OPEN"))
3336            .order_side(OrderSide::Buy)
3337            .last_qty(Quantity::from(2))
3338            .last_px(Price::from("12"))
3339            .position_id(position_id)
3340            .build();
3341        let closing = OrderFilledSpec::builder()
3342            .instrument_id(instrument.id())
3343            .trade_id(TradeId::from("T-CLOSE"))
3344            .order_side(OrderSide::Sell)
3345            .last_qty(Quantity::from(1))
3346            .last_px(Price::from("15"))
3347            .position_id(position_id)
3348            .event_id(UUID4::new())
3349            .build();
3350        let restatement = OrderFilledSpec::builder()
3351            .instrument_id(instrument.id())
3352            .trade_id(TradeId::from("T-CLOSE"))
3353            .order_side(OrderSide::Sell)
3354            .last_qty(Quantity::from(1))
3355            .last_px(Price::from("12.75"))
3356            .position_id(position_id)
3357            .event_id(UUID4::new())
3358            .build();
3359        let mut position = Position::new(&instrument, opening);
3360        position.apply(&closing);
3361        position.apply(&restatement);
3362
3363        assert_eq!(position.quantity.as_decimal(), Decimal::from(1));
3364        assert_eq!(position.side, PositionSide::Long);
3365        assert_eq!(position.avg_px_open, Price::from("12").as_decimal());
3366        assert_eq!(position.avg_px_close, Some(Price::from("15").as_decimal()));
3367        assert_eq!(
3368            position.realized_pnl.map(|pnl| pnl.as_decimal()),
3369            Some(dec!(3))
3370        );
3371        assert_eq!(position.events[1].last_px, Price::from("15"));
3372    }
3373
3374    #[rstest]
3375    fn test_restatement_of_reversal_fill_keeps_flipped_average(audusd_sim: CurrencyPair) {
3376        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3377        let position_id = PositionId::from("P-REVERSAL-RESTATE");
3378        let opening = OrderFilledSpec::builder()
3379            .instrument_id(instrument.id())
3380            .trade_id(TradeId::from("T-OPEN"))
3381            .order_side(OrderSide::Buy)
3382            .last_qty(Quantity::from(2))
3383            .last_px(Price::from("12"))
3384            .position_id(position_id)
3385            .build();
3386        let reversal = OrderFilledSpec::builder()
3387            .instrument_id(instrument.id())
3388            .trade_id(TradeId::from("T-REVERSE"))
3389            .order_side(OrderSide::Sell)
3390            .last_qty(Quantity::from(3))
3391            .last_px(Price::from("10"))
3392            .position_id(position_id)
3393            .event_id(UUID4::new())
3394            .build();
3395        let restatement = OrderFilledSpec::builder()
3396            .instrument_id(instrument.id())
3397            .trade_id(TradeId::from("T-REVERSE"))
3398            .order_side(OrderSide::Sell)
3399            .last_qty(Quantity::from(3))
3400            .last_px(Price::from("9"))
3401            .position_id(position_id)
3402            .event_id(UUID4::new())
3403            .build();
3404        let mut position = Position::new(&instrument, opening);
3405        position.apply(&reversal);
3406        position.apply(&restatement);
3407
3408        assert_eq!(position.side, PositionSide::Short);
3409        assert_eq!(position.quantity.as_decimal(), Decimal::from(1));
3410        assert_eq!(position.avg_px_open, Price::from("10").as_decimal());
3411    }
3412
3413    #[rstest]
3414    fn test_restatement_share_excludes_reversal_closing_quantity(audusd_sim: CurrencyPair) {
3415        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3416        let position_id = PositionId::from("P-REVERSAL-SHARE");
3417        let trade_id = TradeId::from("T-RESTATE");
3418
3419        let mut position = Position::new(
3420            &instrument,
3421            OrderFilledSpec::builder()
3422                .instrument_id(instrument.id())
3423                .trade_id(TradeId::from("T-OPEN"))
3424                .order_side(OrderSide::Buy)
3425                .last_qty(Quantity::from(2))
3426                .last_px(Price::from("12"))
3427                .position_id(position_id)
3428                .build(),
3429        );
3430
3431        for (trade, side, qty, px) in [
3432            ("T-REVERSE", OrderSide::Sell, 3, "10"),
3433            (trade_id.as_str(), OrderSide::Sell, 1, "8"),
3434            ("T-CLOSE", OrderSide::Buy, 1, "9"),
3435        ] {
3436            position.apply(
3437                &OrderFilledSpec::builder()
3438                    .instrument_id(instrument.id())
3439                    .trade_id(TradeId::from(trade))
3440                    .order_side(side)
3441                    .last_qty(Quantity::from(qty))
3442                    .last_px(Price::from(px))
3443                    .position_id(position_id)
3444                    .event_id(UUID4::new())
3445                    .build(),
3446            );
3447        }
3448
3449        assert_eq!(position.side, PositionSide::Short);
3450        assert_eq!(position.quantity.as_decimal(), Decimal::from(1));
3451        assert_eq!(position.avg_px_open, Price::from("9").as_decimal());
3452
3453        position.apply(
3454            &OrderFilledSpec::builder()
3455                .instrument_id(instrument.id())
3456                .trade_id(trade_id)
3457                .order_side(OrderSide::Sell)
3458                .last_qty(Quantity::from(1))
3459                .last_px(Price::from("6"))
3460                .position_id(position_id)
3461                .event_id(UUID4::new())
3462                .build(),
3463        );
3464
3465        assert_eq!(position.avg_px_open, Price::from("8").as_decimal());
3466    }
3467
3468    #[rstest]
3469    fn test_price_restatement_uses_surviving_quantity(audusd_sim: CurrencyPair) {
3470        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3471        let position_id = PositionId::from("P-SURVIVING");
3472        let opening = OrderFilledSpec::builder()
3473            .instrument_id(instrument.id())
3474            .trade_id(TradeId::from("T-1"))
3475            .order_side(OrderSide::Buy)
3476            .last_qty(Quantity::from(2))
3477            .last_px(Price::from("12"))
3478            .position_id(position_id)
3479            .build();
3480        let later = OrderFilledSpec::builder()
3481            .instrument_id(instrument.id())
3482            .trade_id(TradeId::from("T-2"))
3483            .order_side(OrderSide::Buy)
3484            .last_qty(Quantity::from(1))
3485            .last_px(Price::from("10"))
3486            .position_id(position_id)
3487            .event_id(UUID4::new())
3488            .build();
3489        let restatement = OrderFilledSpec::builder()
3490            .instrument_id(instrument.id())
3491            .trade_id(TradeId::from("T-1"))
3492            .order_side(OrderSide::Buy)
3493            .last_qty(Quantity::from(1))
3494            .last_px(Price::from("9.47"))
3495            .position_id(position_id)
3496            .event_id(UUID4::new())
3497            .build();
3498        let mut position = Position::new(&instrument, opening);
3499        let voided = OrderFillVoidedSpec::builder()
3500            .instrument_id(instrument.id())
3501            .trade_id(TradeId::from("T-1"))
3502            .voided_qty(Quantity::from(1))
3503            .last_px(Price::from("12"))
3504            .order_side(OrderSide::Buy)
3505            .position_id(position_id)
3506            .build();
3507        position
3508            .apply_fill_void(voided, Quantity::from(1), None)
3509            .unwrap();
3510        position.apply(&later);
3511        position.apply(&restatement);
3512
3513        let expected = (dec!(11) * dec!(2) - dec!(12) + dec!(9.47)) / dec!(2);
3514        assert_eq!(position.quantity.as_decimal(), Decimal::from(2));
3515        assert_eq!(position.avg_px_open, expected);
3516    }
3517
3518    #[rstest]
3519    fn test_reapplying_same_price_restatement_is_idempotent(audusd_sim: CurrencyPair) {
3520        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3521        let position_id = PositionId::from("P-IDEMPOTENT");
3522        let trade_id = TradeId::from("T-1");
3523        let opening = OrderFilledSpec::builder()
3524            .instrument_id(instrument.id())
3525            .trade_id(trade_id)
3526            .order_side(OrderSide::Buy)
3527            .last_qty(Quantity::from(2))
3528            .last_px(Price::from("12"))
3529            .position_id(position_id)
3530            .build();
3531        let restatement = OrderFilledSpec::builder()
3532            .instrument_id(instrument.id())
3533            .trade_id(trade_id)
3534            .order_side(OrderSide::Buy)
3535            .last_qty(Quantity::from(2))
3536            .last_px(Price::from("9.47"))
3537            .position_id(position_id)
3538            .event_id(UUID4::new())
3539            .build();
3540        let mut position = Position::new(&instrument, opening);
3541        position.apply(&restatement);
3542        let replay_len = position.replay_events.len();
3543        position.apply(&restatement);
3544
3545        assert_eq!(position.avg_px_open, Price::from("9.47").as_decimal());
3546        assert_eq!(position.replay_events.len(), replay_len);
3547    }
3548
3549    #[rstest]
3550    fn test_purge_keeps_price_restatement_on_surviving_order(audusd_sim: CurrencyPair) {
3551        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3552        let position_id = PositionId::from("P-PURGE-RESTATE");
3553        let opening = OrderFilledSpec::builder()
3554            .client_order_id(ClientOrderId::from("O-KEEP"))
3555            .instrument_id(instrument.id())
3556            .trade_id(TradeId::from("T-KEEP"))
3557            .order_side(OrderSide::Buy)
3558            .last_qty(Quantity::from(2))
3559            .last_px(Price::from("12"))
3560            .position_id(position_id)
3561            .build();
3562        let other = OrderFilledSpec::builder()
3563            .client_order_id(ClientOrderId::from("O-DROP"))
3564            .instrument_id(instrument.id())
3565            .trade_id(TradeId::from("T-DROP"))
3566            .order_side(OrderSide::Buy)
3567            .last_qty(Quantity::from(1))
3568            .last_px(Price::from("10"))
3569            .position_id(position_id)
3570            .event_id(UUID4::new())
3571            .build();
3572        let restatement = OrderFilledSpec::builder()
3573            .client_order_id(ClientOrderId::from("O-KEEP"))
3574            .instrument_id(instrument.id())
3575            .trade_id(TradeId::from("T-KEEP"))
3576            .order_side(OrderSide::Buy)
3577            .last_qty(Quantity::from(2))
3578            .last_px(Price::from("9.47"))
3579            .position_id(position_id)
3580            .event_id(UUID4::new())
3581            .build();
3582        let mut position = Position::new(&instrument, opening);
3583        position.apply(&other);
3584        position.apply(&restatement);
3585        position
3586            .purge_events_for_order(ClientOrderId::from("O-DROP"))
3587            .unwrap();
3588
3589        assert_eq!(position.quantity.as_decimal(), Decimal::from(2));
3590        assert_eq!(position.avg_px_open, Price::from("9.47").as_decimal());
3591    }
3592
3593    #[rstest]
3594    fn test_price_restatement_excludes_closed_quantity(audusd_sim: CurrencyPair) {
3595        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3596        let position_id = PositionId::from("P-CLOSED-QTY");
3597        let opening = OrderFilledSpec::builder()
3598            .instrument_id(instrument.id())
3599            .trade_id(TradeId::from("T-1"))
3600            .order_side(OrderSide::Buy)
3601            .last_qty(Quantity::from(2))
3602            .last_px(Price::from("12"))
3603            .position_id(position_id)
3604            .build();
3605        let closing = OrderFilledSpec::builder()
3606            .instrument_id(instrument.id())
3607            .trade_id(TradeId::from("T-CLOSE"))
3608            .order_side(OrderSide::Sell)
3609            .last_qty(Quantity::from(1))
3610            .last_px(Price::from("15"))
3611            .position_id(position_id)
3612            .event_id(UUID4::new())
3613            .build();
3614        let later = OrderFilledSpec::builder()
3615            .instrument_id(instrument.id())
3616            .trade_id(TradeId::from("T-2"))
3617            .order_side(OrderSide::Buy)
3618            .last_qty(Quantity::from(1))
3619            .last_px(Price::from("10"))
3620            .position_id(position_id)
3621            .event_id(UUID4::new())
3622            .build();
3623        let restatement = OrderFilledSpec::builder()
3624            .instrument_id(instrument.id())
3625            .trade_id(TradeId::from("T-1"))
3626            .order_side(OrderSide::Buy)
3627            .last_qty(Quantity::from(2))
3628            .last_px(Price::from("9.47"))
3629            .position_id(position_id)
3630            .event_id(UUID4::new())
3631            .build();
3632        let mut position = Position::new(&instrument, opening);
3633        position.apply(&closing);
3634        position.apply(&later);
3635        position.apply(&restatement);
3636
3637        let expected = (dec!(11) * dec!(2) - dec!(12) + dec!(9.47)) / dec!(2);
3638        assert_eq!(position.quantity.as_decimal(), Decimal::from(2));
3639        assert_eq!(position.avg_px_open, expected);
3640    }
3641
3642    #[rstest]
3643    fn test_price_restatement_after_close_across_two_lots_uses_average_cost(
3644        audusd_sim: CurrencyPair,
3645    ) {
3646        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3647        let position_id = PositionId::from("P-AVG-COST");
3648        let first = OrderFilledSpec::builder()
3649            .instrument_id(instrument.id())
3650            .trade_id(TradeId::from("T-1"))
3651            .order_side(OrderSide::Buy)
3652            .last_qty(Quantity::from(2))
3653            .last_px(Price::from("12"))
3654            .position_id(position_id)
3655            .build();
3656        let second = OrderFilledSpec::builder()
3657            .instrument_id(instrument.id())
3658            .trade_id(TradeId::from("T-2"))
3659            .order_side(OrderSide::Buy)
3660            .last_qty(Quantity::from(2))
3661            .last_px(Price::from("10"))
3662            .position_id(position_id)
3663            .event_id(UUID4::new())
3664            .build();
3665        let closing = OrderFilledSpec::builder()
3666            .instrument_id(instrument.id())
3667            .trade_id(TradeId::from("T-CLOSE"))
3668            .order_side(OrderSide::Sell)
3669            .last_qty(Quantity::from(2))
3670            .last_px(Price::from("15"))
3671            .position_id(position_id)
3672            .event_id(UUID4::new())
3673            .build();
3674        let restatement = OrderFilledSpec::builder()
3675            .instrument_id(instrument.id())
3676            .trade_id(TradeId::from("T-1"))
3677            .order_side(OrderSide::Buy)
3678            .last_qty(Quantity::from(2))
3679            .last_px(Price::from("9.47"))
3680            .position_id(position_id)
3681            .event_id(UUID4::new())
3682            .build();
3683        let mut position = Position::new(&instrument, first);
3684        position.apply(&second);
3685        position.apply(&closing);
3686        position.apply(&restatement);
3687
3688        let expected = (dec!(11) * dec!(2) - dec!(12) + dec!(9.47)) / dec!(2);
3689        assert_eq!(position.quantity.as_decimal(), Decimal::from(2));
3690        assert_eq!(position.avg_px_open, expected);
3691    }
3692
3693    #[rstest]
3694    fn test_purge_applies_restatement_before_later_close(audusd_sim: CurrencyPair) {
3695        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3696        let position_id = PositionId::from("P-PURGE-ORDER");
3697        let opening = OrderFilledSpec::builder()
3698            .client_order_id(ClientOrderId::from("O-KEEP"))
3699            .instrument_id(instrument.id())
3700            .trade_id(TradeId::from("T-KEEP"))
3701            .order_side(OrderSide::Buy)
3702            .last_qty(Quantity::from(2))
3703            .last_px(Price::from("12"))
3704            .position_id(position_id)
3705            .build();
3706        let restatement = OrderFilledSpec::builder()
3707            .client_order_id(ClientOrderId::from("O-KEEP"))
3708            .instrument_id(instrument.id())
3709            .trade_id(TradeId::from("T-KEEP"))
3710            .order_side(OrderSide::Buy)
3711            .last_qty(Quantity::from(2))
3712            .last_px(Price::from("9.47"))
3713            .position_id(position_id)
3714            .event_id(UUID4::new())
3715            .build();
3716        let closing = OrderFilledSpec::builder()
3717            .client_order_id(ClientOrderId::from("O-CLOSE"))
3718            .instrument_id(instrument.id())
3719            .trade_id(TradeId::from("T-CLOSE"))
3720            .order_side(OrderSide::Sell)
3721            .last_qty(Quantity::from(1))
3722            .last_px(Price::from("15"))
3723            .position_id(position_id)
3724            .event_id(UUID4::new())
3725            .build();
3726        let other = OrderFilledSpec::builder()
3727            .client_order_id(ClientOrderId::from("O-DROP"))
3728            .instrument_id(instrument.id())
3729            .trade_id(TradeId::from("T-DROP"))
3730            .order_side(OrderSide::Buy)
3731            .last_qty(Quantity::from(1))
3732            .last_px(Price::from("10"))
3733            .position_id(position_id)
3734            .event_id(UUID4::new())
3735            .build();
3736        let mut position = Position::new(&instrument, opening);
3737        position.apply(&restatement);
3738        position.apply(&closing);
3739        let pnl_before = position.realized_pnl;
3740        let avg_before = position.avg_px_open;
3741        position.apply(&other);
3742        position
3743            .purge_events_for_order(ClientOrderId::from("O-DROP"))
3744            .unwrap();
3745
3746        assert_eq!(position.realized_pnl, pnl_before);
3747        assert_eq!(position.avg_px_open, avg_before);
3748        assert_eq!(position.quantity.as_decimal(), Decimal::from(1));
3749    }
3750
3751    #[rstest]
3752    fn test_full_void_after_restatement_does_not_reopen(audusd_sim: CurrencyPair) {
3753        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3754        let position_id = PositionId::from("P-VOID-RESTATE");
3755        let trade_id = TradeId::from("T-1");
3756        let opening = OrderFilledSpec::builder()
3757            .instrument_id(instrument.id())
3758            .trade_id(trade_id)
3759            .order_side(OrderSide::Buy)
3760            .last_qty(Quantity::from(2))
3761            .last_px(Price::from("12"))
3762            .position_id(position_id)
3763            .build();
3764        let restatement = OrderFilledSpec::builder()
3765            .instrument_id(instrument.id())
3766            .trade_id(trade_id)
3767            .order_side(OrderSide::Buy)
3768            .last_qty(Quantity::from(2))
3769            .last_px(Price::from("9.47"))
3770            .position_id(position_id)
3771            .event_id(UUID4::new())
3772            .build();
3773        let mut position = Position::new(&instrument, opening);
3774        position.apply(&restatement);
3775        let voided = OrderFillVoidedSpec::builder()
3776            .instrument_id(instrument.id())
3777            .trade_id(trade_id)
3778            .voided_qty(Quantity::from(2))
3779            .last_px(Price::from("12"))
3780            .order_side(OrderSide::Buy)
3781            .position_id(position_id)
3782            .build();
3783        position
3784            .apply_fill_void(voided, Quantity::from(2), None)
3785            .unwrap();
3786
3787        assert_eq!(position.side, PositionSide::Flat);
3788        assert!(position.quantity.is_zero());
3789    }
3790
3791    #[rstest]
3792    fn test_return_to_original_price_then_full_void_stays_flat(audusd_sim: CurrencyPair) {
3793        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3794        let position_id = PositionId::from("P-PRICE-ROUNDTRIP");
3795        let trade_id = TradeId::from("T-1");
3796        let opening = OrderFilledSpec::builder()
3797            .instrument_id(instrument.id())
3798            .trade_id(trade_id)
3799            .order_side(OrderSide::Buy)
3800            .last_qty(Quantity::from(2))
3801            .last_px(Price::from("12"))
3802            .position_id(position_id)
3803            .build();
3804        let restated = OrderFilledSpec::builder()
3805            .instrument_id(instrument.id())
3806            .trade_id(trade_id)
3807            .order_side(OrderSide::Buy)
3808            .last_qty(Quantity::from(2))
3809            .last_px(Price::from("9.47"))
3810            .position_id(position_id)
3811            .event_id(UUID4::new())
3812            .build();
3813        let restored = OrderFilledSpec::builder()
3814            .instrument_id(instrument.id())
3815            .trade_id(trade_id)
3816            .order_side(OrderSide::Buy)
3817            .last_qty(Quantity::from(2))
3818            .last_px(Price::from("12"))
3819            .position_id(position_id)
3820            .event_id(UUID4::new())
3821            .build();
3822        let mut position = Position::new(&instrument, opening);
3823        position.apply(&restated);
3824        position.apply(&restored);
3825        let voided = OrderFillVoidedSpec::builder()
3826            .instrument_id(instrument.id())
3827            .trade_id(trade_id)
3828            .voided_qty(Quantity::from(2))
3829            .last_px(Price::from("12"))
3830            .order_side(OrderSide::Buy)
3831            .position_id(position_id)
3832            .build();
3833        position
3834            .apply_fill_void(voided, Quantity::from(2), None)
3835            .unwrap();
3836
3837        assert_eq!(position.side, PositionSide::Flat);
3838        assert!(position.quantity.is_zero());
3839    }
3840
3841    #[rstest]
3842    fn test_purge_keeps_voided_quantity_on_surviving_order(audusd_sim: CurrencyPair) {
3843        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
3844        let position_id = PositionId::from("P-PURGE-VOID");
3845        let opening = OrderFilledSpec::builder()
3846            .client_order_id(ClientOrderId::from("O-KEEP"))
3847            .instrument_id(instrument.id())
3848            .trade_id(TradeId::from("T-KEEP"))
3849            .order_side(OrderSide::Buy)
3850            .last_qty(Quantity::from(2))
3851            .last_px(Price::from("12"))
3852            .position_id(position_id)
3853            .build();
3854        let other = OrderFilledSpec::builder()
3855            .client_order_id(ClientOrderId::from("O-DROP"))
3856            .instrument_id(instrument.id())
3857            .trade_id(TradeId::from("T-DROP"))
3858            .order_side(OrderSide::Buy)
3859            .last_qty(Quantity::from(1))
3860            .last_px(Price::from("10"))
3861            .position_id(position_id)
3862            .event_id(UUID4::new())
3863            .build();
3864        let mut position = Position::new(&instrument, opening);
3865        let voided = OrderFillVoidedSpec::builder()
3866            .client_order_id(ClientOrderId::from("O-KEEP"))
3867            .instrument_id(instrument.id())
3868            .trade_id(TradeId::from("T-KEEP"))
3869            .voided_qty(Quantity::from(1))
3870            .last_px(Price::from("12"))
3871            .order_side(OrderSide::Buy)
3872            .position_id(position_id)
3873            .build();
3874        position
3875            .apply_fill_void(voided, Quantity::from(1), None)
3876            .unwrap();
3877        position.apply(&other);
3878        position
3879            .purge_events_for_order(ClientOrderId::from("O-DROP"))
3880            .unwrap();
3881
3882        assert_eq!(position.quantity.as_decimal(), Decimal::from(1));
3883    }
3884
3885    #[rstest]
3886    fn test_position_long_display(stub_position_long: Position) {
3887        let display = format!("{stub_position_long}");
3888        assert_eq!(display, "Position(LONG 1 AUD/USD.SIM, id=1)");
3889    }
3890
3891    #[rstest]
3892    fn test_position_short_display(stub_position_short: Position) {
3893        let display = format!("{stub_position_short}");
3894        assert_eq!(display, "Position(SHORT 1 AUD/USD.SIM, id=1)");
3895    }
3896
3897    #[rstest]
3898    #[case::commodity(InstrumentAny::Commodity(commodity_gold()), true)]
3899    #[case::equity(InstrumentAny::Equity(equity_aapl()), false)]
3900    fn test_negative_price_allowance_survives_snapshot_and_serialization(
3901        #[case] instrument: InstrumentAny,
3902        #[case] expected: bool,
3903    ) {
3904        let fill = OrderFilledSpec::builder()
3905            .instrument_id(instrument.id())
3906            .position_id(PositionId::new("P-PRICE-POLICY"))
3907            .last_qty(Quantity::from(1))
3908            .last_px(Price::from("10.00"))
3909            .currency(Currency::USD())
3910            .build();
3911        let position = Position::new(&instrument, fill);
3912        let snapshot = position.clone_without_events();
3913        let mut serialized = serde_json::to_value(&position).unwrap();
3914        let restored: Position = serde_json::from_value(serialized.clone()).unwrap();
3915        let serialized_allowance = serialized
3916            .as_object_mut()
3917            .unwrap()
3918            .remove("allows_negative_price");
3919        let legacy: Position = serde_json::from_value(serialized).unwrap();
3920
3921        assert_eq!(position.allows_negative_price, Some(expected));
3922        assert_eq!(snapshot.allows_negative_price, Some(expected));
3923        assert_eq!(restored.allows_negative_price, Some(expected));
3924        assert_eq!(serialized_allowance, Some(serde_json::json!(expected)));
3925        assert_eq!(legacy.allows_negative_price, None);
3926    }
3927
3928    #[rstest]
3929    #[case::open(false)]
3930    #[case::closed(true)]
3931    fn test_clone_without_events_preserves_current_state(
3932        mut stub_position_long: Position,
3933        #[case] close: bool,
3934    ) {
3935        let adjustment = PositionAdjusted::new(
3936            stub_position_long.trader_id,
3937            stub_position_long.strategy_id,
3938            stub_position_long.instrument_id,
3939            stub_position_long.id,
3940            stub_position_long.account_id,
3941            PositionAdjustmentType::Funding,
3942            None,
3943            Some(Money::from_decimal(dec!(1.25), stub_position_long.settlement_currency).unwrap()),
3944            Some("clone-test".into()),
3945            uuid4(),
3946            UnixNanos::from(2),
3947            UnixNanos::from(2),
3948        );
3949        stub_position_long.apply_adjustment(adjustment).unwrap();
3950
3951        if close {
3952            let closing_fill = OrderFilledSpec::builder()
3953                .trader_id(stub_position_long.trader_id)
3954                .strategy_id(stub_position_long.strategy_id)
3955                .instrument_id(stub_position_long.instrument_id)
3956                .client_order_id(ClientOrderId::from("CLONE-CLOSE"))
3957                .venue_order_id(VenueOrderId::from("CLONE-CLOSE"))
3958                .account_id(stub_position_long.account_id)
3959                .trade_id(TradeId::from("CLONE-CLOSE"))
3960                .order_side(OrderSide::Sell)
3961                .order_type(OrderType::Market)
3962                .last_qty(stub_position_long.quantity)
3963                .last_px(Price::from("1.0012"))
3964                .currency(stub_position_long.settlement_currency)
3965                .position_id(stub_position_long.id)
3966                .ts_event(UnixNanos::from(3))
3967                .ts_init(UnixNanos::from(3))
3968                .build();
3969            stub_position_long.apply(&closing_fill);
3970        }
3971
3972        let source_fill = stub_position_long.events[0].clone();
3973        let fill_voided = matching_fill_void(&source_fill, source_fill.last_qty, None);
3974        stub_position_long.fill_voids.push(PositionFillVoid {
3975            event: fill_voided,
3976            voided_qty: source_fill.last_qty,
3977            commission_voided: source_fill.commission,
3978        });
3979
3980        let cloned = stub_position_long.clone_without_events();
3981        let mut expected = stub_position_long.clone();
3982        expected.events.clear();
3983        expected.adjustments.clear();
3984        expected.replay_events.clear();
3985        expected.fill_voids.clear();
3986        expected.trade_ids.clear();
3987
3988        assert!(!stub_position_long.events.is_empty());
3989        assert!(!stub_position_long.adjustments.is_empty());
3990        assert!(!stub_position_long.replay_events.is_empty());
3991        assert!(!stub_position_long.fill_voids.is_empty());
3992        assert!(!stub_position_long.trade_ids.is_empty());
3993        assert!(cloned.events.is_empty());
3994        assert!(cloned.adjustments.is_empty());
3995        assert!(cloned.replay_events.is_empty());
3996        assert!(cloned.fill_voids.is_empty());
3997        assert!(cloned.trade_ids.is_empty());
3998        assert_eq!(
3999            serde_json::to_value(cloned).unwrap(),
4000            serde_json::to_value(expected).unwrap()
4001        );
4002    }
4003
4004    #[rstest]
4005    fn test_clone_for_snapshot_matches_clone_then_clear(mut stub_position_long: Position) {
4006        let source_fill = stub_position_long.events[0].clone();
4007        stub_position_long.fill_voids.push(PositionFillVoid {
4008            event: matching_fill_void(&source_fill, source_fill.last_qty, None),
4009            voided_qty: source_fill.last_qty,
4010            commission_voided: source_fill.commission,
4011        });
4012        let mut expected = stub_position_long.clone();
4013        expected.replay_events.clear();
4014        expected.fill_voids.clear();
4015
4016        let snapshot = stub_position_long.clone_for_snapshot();
4017
4018        assert!(snapshot.replay_events.is_empty());
4019        assert!(snapshot.fill_voids.is_empty());
4020        assert_eq!(
4021            serde_json::to_vec(&snapshot).unwrap(),
4022            serde_json::to_vec(&expected).unwrap(),
4023        );
4024    }
4025
4026    #[rstest]
4027    fn test_new_checked_rejects_missing_position_id(audusd_sim: CurrencyPair) {
4028        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
4029        let fill = OrderFilledSpec::builder()
4030            .instrument_id(instrument.id())
4031            .build();
4032
4033        let error = Position::new_checked(&instrument, fill).unwrap_err();
4034
4035        assert_eq!(
4036            error,
4037            CorrectnessError::PredicateViolation {
4038                message: "`fill.position_id` was None".to_string(),
4039            }
4040        );
4041    }
4042
4043    #[rstest]
4044    fn test_new_checked_rejects_instrument_mismatch(audusd_sim: CurrencyPair) {
4045        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
4046        let fill = OrderFilledSpec::builder()
4047            .instrument_id(InstrumentId::from("GBP/USD.SIM"))
4048            .position_id(PositionId::from("P-1"))
4049            .build();
4050
4051        let error = Position::new_checked(&instrument, fill).unwrap_err();
4052
4053        assert_eq!(
4054            error,
4055            CorrectnessError::EqualityMismatch {
4056                lhs_param: "instrument.id()".to_string(),
4057                rhs_param: "fill.instrument_id".to_string(),
4058                lhs: "AUD/USD.SIM".to_string(),
4059                rhs: "GBP/USD.SIM".to_string(),
4060                type_name: "value",
4061            }
4062        );
4063    }
4064
4065    #[rstest]
4066    #[case::instrument_mismatch(
4067        "GBP/USD.SIM",
4068        Some("P-1"),
4069        "'self.instrument_id' value of AUD/USD.SIM was not equal to 'fill.instrument_id' value of GBP/USD.SIM"
4070    )]
4071    #[case::missing_position_id("AUD/USD.SIM", None, "`fill.position_id` was None")]
4072    #[case::position_mismatch(
4073        "AUD/USD.SIM",
4074        Some("P-2"),
4075        "'self.id' value of P-1 was not equal to 'fill.position_id' value of P-2"
4076    )]
4077    fn test_try_apply_rejects_invalid_fill_identity_without_mutation(
4078        #[case] fill_instrument_id: &str,
4079        #[case] fill_position_id: Option<&str>,
4080        #[case] expected_error: &str,
4081        audusd_sim: CurrencyPair,
4082    ) {
4083        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
4084        let position_id = PositionId::from("P-1");
4085        let fill_open = OrderFilledSpec::builder()
4086            .instrument_id(instrument.id())
4087            .trade_id(TradeId::from("T-1"))
4088            .position_id(position_id)
4089            .build();
4090        let mut fill_invalid = OrderFilledSpec::builder()
4091            .instrument_id(InstrumentId::from(fill_instrument_id))
4092            .trade_id(TradeId::from("T-2"))
4093            .build();
4094        fill_invalid.position_id = fill_position_id.map(PositionId::from);
4095        let mut position = Position::new(&instrument, fill_open);
4096        let state_before = serde_json::to_value(&position).unwrap();
4097
4098        let error = position.try_apply(&fill_invalid).unwrap_err();
4099
4100        assert_eq!(error.to_string(), expected_error);
4101        assert_eq!(serde_json::to_value(&position).unwrap(), state_before);
4102    }
4103
4104    #[rstest]
4105    fn test_try_apply_rejects_duplicate_trade_without_mutation(audusd_sim: CurrencyPair) {
4106        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
4107        let position_id = PositionId::from("P-1");
4108        let fill_open = OrderFilledSpec::builder()
4109            .instrument_id(instrument.id())
4110            .trade_id(TradeId::from("T-1"))
4111            .position_id(position_id)
4112            .build();
4113        let fill_duplicate = OrderFilledSpec::builder()
4114            .instrument_id(instrument.id())
4115            .client_order_id(ClientOrderId::from("O-2"))
4116            .trade_id(TradeId::from("T-1"))
4117            .position_id(position_id)
4118            .build();
4119        let mut position = Position::new(&instrument, fill_open);
4120        let state_before = serde_json::to_value(&position).unwrap();
4121
4122        let error = position.try_apply(&fill_duplicate).unwrap_err();
4123
4124        assert_eq!(
4125            error,
4126            CorrectnessError::PredicateViolation {
4127                message: "`fill.trade_id` already contained in `trade_ids`".to_string(),
4128            }
4129        );
4130        assert_eq!(serde_json::to_value(&position).unwrap(), state_before);
4131    }
4132
4133    #[cfg(feature = "defi")]
4134    #[rstest]
4135    #[case::price_17("1.00000000000000001", "100000", None)]
4136    #[case::price_18("1.000000000000000001", "100000", None)]
4137    #[case::quantity_18("1.00000", "1.000000000000000001", None)]
4138    #[case::settlement_commission_18("1.00000", "100000", Some(("USD", 18)))]
4139    #[case::base_commission_18("1.00000", "100000", Some(("AUD", 18)))]
4140    fn test_new_checked_preserves_high_precision_fill_values(
4141        #[case] last_px: &str,
4142        #[case] last_qty: &str,
4143        #[case] commission: Option<(&str, u8)>,
4144        audusd_sim: CurrencyPair,
4145    ) {
4146        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
4147        let mut fill = OrderFilledSpec::builder()
4148            .instrument_id(instrument.id())
4149            .last_px(Price::from(last_px))
4150            .last_qty(Quantity::from(last_qty))
4151            .position_id(PositionId::from("P-1"))
4152            .build();
4153        fill.commission = commission.map(|(code, precision)| {
4154            let currency = Currency::new(code, precision, 0, code, CurrencyType::Fiat);
4155            Money::from_decimal(dec!(1), currency).unwrap()
4156        });
4157
4158        let position = Position::new_checked(&instrument, fill.clone()).unwrap();
4159
4160        let expected_qty = if commission.is_some_and(|(code, _)| code == "AUD") {
4161            dec!(99999)
4162        } else {
4163            last_qty.parse().unwrap()
4164        };
4165
4166        assert_eq!(position.avg_px_open, last_px.parse::<Decimal>().unwrap());
4167        assert_eq!(position.signed_qty, expected_qty);
4168        assert_eq!(position.quantity.as_decimal(), expected_qty);
4169        assert_eq!(
4170            position.commissions(),
4171            fill.commission.into_iter().collect::<Vec<_>>()
4172        );
4173    }
4174
4175    #[cfg(feature = "defi")]
4176    #[rstest]
4177    #[case::size_precision(18, 0, 2)]
4178    #[case::multiplier(0, 18, 2)]
4179    #[case::settlement_currency(0, 0, 18)]
4180    fn test_new_checked_accepts_high_precision_instrument(
4181        #[case] size_precision: u8,
4182        #[case] multiplier_precision: u8,
4183        #[case] quote_precision: u8,
4184        mut audusd_sim: CurrencyPair,
4185    ) {
4186        audusd_sim.size_precision = size_precision;
4187        audusd_sim.multiplier = Quantity::from_decimal_dp(dec!(1), multiplier_precision).unwrap();
4188        audusd_sim.quote_currency =
4189            Currency::new("USD", quote_precision, 840, "US dollar", CurrencyType::Fiat);
4190        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
4191        let fill = OrderFilledSpec::builder()
4192            .instrument_id(instrument.id())
4193            .position_id(PositionId::from("P-1"))
4194            .build();
4195
4196        let position = Position::new_checked(&instrument, fill).unwrap();
4197
4198        assert_eq!(position.size_precision, size_precision);
4199        assert_eq!(position.multiplier.precision, multiplier_precision);
4200        assert_eq!(position.settlement_currency.precision, quote_precision);
4201    }
4202
4203    #[cfg(feature = "defi")]
4204    #[rstest]
4205    fn test_new_checked_preserves_sixteen_digit_inputs(audusd_sim: CurrencyPair) {
4206        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
4207        let usd = Currency::new("USD", 16, 840, "US dollar", CurrencyType::Fiat);
4208        let mut fill = OrderFilledSpec::builder()
4209            .instrument_id(instrument.id())
4210            .last_px(Price::from("1.5000000000000000"))
4211            .last_qty(Quantity::from("2.0000000000000000"))
4212            .position_id(PositionId::from("P-1"))
4213            .build();
4214        fill.commission = Some(Money::from_decimal(dec!(0.25), usd).unwrap());
4215
4216        let position = Position::new_checked(&instrument, fill).unwrap();
4217
4218        assert_eq!(position.avg_px_open, dec!(1.5));
4219        assert_eq!(position.signed_qty, dec!(2.0));
4220        assert_eq!(position.quantity, Quantity::from("2.0000000000000000"));
4221        assert_eq!(position.realized_pnl, Some(Money::from("-0.25 USD")));
4222    }
4223
4224    #[cfg(feature = "defi")]
4225    #[rstest]
4226    fn test_new_checked_preserves_eighteen_digit_foreign_commission(audusd_sim: CurrencyPair) {
4227        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
4228        let wei = Currency::new("WEI", 18, 0, "Wei", CurrencyType::Crypto);
4229        let commission = Money::from_decimal(dec!(0.000000000000000001), wei).unwrap();
4230        let mut fill = OrderFilledSpec::builder()
4231            .instrument_id(instrument.id())
4232            .position_id(PositionId::from("P-1"))
4233            .build();
4234        fill.commission = Some(commission);
4235
4236        let position = Position::new_checked(&instrument, fill).unwrap();
4237
4238        assert_eq!(position.commissions(), vec![commission]);
4239        assert_eq!(position.realized_pnl, Some(Money::from("0 USD")));
4240    }
4241
4242    #[cfg(feature = "defi")]
4243    #[rstest]
4244    #[case::price("price")]
4245    #[case::foreign_commission("foreign_commission")]
4246    fn test_try_apply_rejects_unrepresentable_input_without_mutation(
4247        audusd_sim: CurrencyPair,
4248        #[case] input: &str,
4249    ) {
4250        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
4251        let position_id = PositionId::from("P-1");
4252        let fill_open = OrderFilledSpec::builder()
4253            .instrument_id(instrument.id())
4254            .trade_id(TradeId::from("T-1"))
4255            .position_id(position_id)
4256            .build();
4257        let mut fill_invalid = OrderFilledSpec::builder()
4258            .instrument_id(instrument.id())
4259            .trade_id(TradeId::from("T-2"))
4260            .position_id(position_id)
4261            .build();
4262
4263        match input {
4264            "price" => fill_invalid.last_px = Price::from("100000000000.000000000000000001"),
4265            "foreign_commission" => {
4266                fill_invalid.commission = Some(Money::from_raw(
4267                    100_000_000_000_000_000_000_000_000_001,
4268                    Currency::EUR(),
4269                ));
4270            }
4271            _ => unreachable!(),
4272        }
4273
4274        assert_eq!(
4275            Position::new_checked(&instrument, fill_invalid.clone())
4276                .unwrap_err()
4277                .to_string(),
4278            "position input exceeds exact Decimal representation",
4279        );
4280        let mut position = Position::new(&instrument, fill_open);
4281        let state_before = serde_json::to_value(&position).unwrap();
4282
4283        let error = position.try_apply(&fill_invalid).unwrap_err();
4284
4285        assert_eq!(
4286            error.to_string(),
4287            "position input exceeds exact Decimal representation"
4288        );
4289        assert_eq!(serde_json::to_value(&position).unwrap(), state_before);
4290    }
4291
4292    #[cfg(feature = "defi")]
4293    #[rstest]
4294    #[case::unchanged(|_: &mut Position| {})]
4295    #[case::buy_qty(
4296        |position: &mut Position| position.buy_qty = Quantity::from("1.000000000000000001")
4297    )]
4298    #[case::sell_qty(
4299        |position: &mut Position| position.sell_qty = Quantity::from("1.000000000000000001")
4300    )]
4301    #[case::event_fill(
4302        |position: &mut Position| position.events[0].last_px = Price::from("1.000000000000000001")
4303    )]
4304    #[case::replay_fill(
4305        |position: &mut Position| {
4306            let mut fill = position.events[0].clone();
4307            fill.last_qty = Quantity::from("1.00000000000000001");
4308            position.replay_events.push(PositionReplayEvent::Filled(fill));
4309        }
4310    )]
4311    #[case::replay_close(
4312        |position: &mut Position| {
4313            let close = InstrumentClose::new(
4314                position.instrument_id,
4315                Price::from("1.000000000000000001"),
4316                InstrumentCloseType::ContractExpired,
4317                UnixNanos::default(),
4318                UnixNanos::default(),
4319            );
4320            position.replay_events.push(PositionReplayEvent::InstrumentClosed(close));
4321        }
4322    )]
4323    #[case::realized_pnl(
4324        |position: &mut Position| {
4325            let usd = Currency::new("USD", 18, 840, "US dollar", CurrencyType::Fiat);
4326            position.realized_pnl = Some(Money::from_decimal(dec!(1), usd).unwrap());
4327        }
4328    )]
4329    fn test_check_accounting_accepts_high_precision_stored_values(
4330        #[case] mutate: fn(&mut Position),
4331        mut stub_position_long: Position,
4332    ) {
4333        mutate(&mut stub_position_long);
4334
4335        let result = stub_position_long.check_accounting();
4336
4337        assert_eq!(result, Ok(()));
4338    }
4339
4340    #[cfg(feature = "defi")]
4341    #[rstest]
4342    fn test_try_pnl_preserves_eighteen_digit_inputs(stub_position_long: Position) {
4343        let last = Price::from("1.000000000000000001");
4344        let quantity = Quantity::from("1.000000000000000001");
4345
4346        let unrealized = stub_position_long.try_unrealized_pnl(last).unwrap();
4347        let total = stub_position_long.try_total_pnl(last).unwrap();
4348        let calculated = stub_position_long
4349            .try_calculate_pnl(dec!(1.0), dec!(1.0), quantity)
4350            .unwrap();
4351
4352        assert_eq!(unrealized, Money::from_str_exact("-0.0002 USD").unwrap());
4353        assert_eq!(total, Money::from_str_exact("-2.0002 USD").unwrap());
4354        assert_eq!(calculated, Money::zero(Currency::USD()));
4355    }
4356
4357    #[rstest]
4358    #[should_panic(expected = "`fill.trade_id` already contained in `trade_ids`")]
4359    fn test_two_trades_with_same_trade_id_error(audusd_sim: CurrencyPair) {
4360        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
4361        let order1 = OrderTestBuilder::new(OrderType::Market)
4362            .client_order_id(ClientOrderId::from("O-1"))
4363            .instrument_id(audusd_sim.id())
4364            .side(OrderSide::Buy)
4365            .quantity(Quantity::from(100_000))
4366            .build();
4367        let order2 = OrderTestBuilder::new(OrderType::Market)
4368            .client_order_id(ClientOrderId::from("O-2"))
4369            .instrument_id(audusd_sim.id())
4370            .side(OrderSide::Buy)
4371            .quantity(Quantity::from(100_000))
4372            .build();
4373        let fill1 = TestOrderEventStubs::filled(
4374            &order1,
4375            &audusd_sim,
4376            Some(TradeId::new("1")),
4377            None,
4378            Some(Price::from("1.00001")),
4379            None,
4380            None,
4381            None,
4382            None,
4383            None,
4384        );
4385        let fill2 = TestOrderEventStubs::filled(
4386            &order2,
4387            &audusd_sim,
4388            Some(TradeId::new("1")),
4389            None,
4390            Some(Price::from("1.00002")),
4391            None,
4392            None,
4393            None,
4394            None,
4395            None,
4396        );
4397        let mut position = Position::new(&audusd_sim, fill1.into());
4398        position.apply(&fill2.into());
4399    }
4400
4401    #[rstest]
4402    #[case(false)]
4403    #[case(true)]
4404    fn test_historical_duplicate_trade_id_does_not_poison_fill_void_replay(
4405        #[case] causal_duplicate: bool,
4406        audusd_sim: CurrencyPair,
4407    ) {
4408        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
4409        let position_id = PositionId::from("P-DUP");
4410        let fill_open = OrderFilledSpec::builder()
4411            .instrument_id(instrument.id())
4412            .client_order_id(ClientOrderId::from("O-1"))
4413            .trade_id(TradeId::from("T-1"))
4414            .order_side(OrderSide::Buy)
4415            .last_qty(Quantity::from(10))
4416            .last_px(Price::from("1.00000"))
4417            .currency(Currency::USD())
4418            .position_id(position_id)
4419            .ts_event(UnixNanos::from(1))
4420            .build();
4421        let fill_close = OrderFilledSpec::builder()
4422            .instrument_id(instrument.id())
4423            .client_order_id(ClientOrderId::from("O-2"))
4424            .trade_id(TradeId::from("T-2"))
4425            .order_side(OrderSide::Sell)
4426            .last_qty(Quantity::from(10))
4427            .last_px(Price::from("1.00010"))
4428            .currency(Currency::USD())
4429            .position_id(position_id)
4430            .ts_event(UnixNanos::from(2))
4431            .build();
4432        let mut fill_duplicate = OrderFilledSpec::builder()
4433            .instrument_id(instrument.id())
4434            .client_order_id(ClientOrderId::from("O-1"))
4435            .trade_id(TradeId::from("T-1"))
4436            .order_side(OrderSide::Buy)
4437            .last_qty(Quantity::from(10))
4438            .last_px(Price::from("1.00020"))
4439            .currency(Currency::USD())
4440            .position_id(position_id)
4441            .ts_event(UnixNanos::from(3))
4442            .build();
4443
4444        if causal_duplicate {
4445            fill_duplicate.causation_id = Some(fill_open.event_id);
4446        }
4447        let fill_reopen = OrderFilledSpec::builder()
4448            .instrument_id(instrument.id())
4449            .client_order_id(ClientOrderId::from("O-3"))
4450            .trade_id(TradeId::from("T-3"))
4451            .order_side(OrderSide::Buy)
4452            .last_qty(Quantity::from(5))
4453            .last_px(Price::from("1.00000"))
4454            .currency(Currency::USD())
4455            .position_id(position_id)
4456            .ts_event(UnixNanos::from(4))
4457            .build();
4458        let mut fill_duplicate_open = fill_duplicate.clone();
4459        fill_duplicate_open.event_id = uuid4();
4460        fill_duplicate_open.client_order_id = ClientOrderId::from("O-4");
4461        fill_duplicate_open.ts_event = UnixNanos::from(5);
4462        let fill_voided = matching_fill_void(&fill_close, Quantity::from(10), None);
4463        let mut position = Position::new(&instrument, fill_open.clone());
4464        position.try_apply(&fill_close).unwrap();
4465
4466        position.try_apply(&fill_duplicate).unwrap();
4467
4468        assert_eq!(position.side, PositionSide::Flat);
4469        assert_eq!(position.quantity, Quantity::from(0));
4470        assert_eq!(position.events, vec![fill_open.clone(), fill_close.clone()]);
4471        assert_eq!(position.replay_events.len(), 2);
4472        assert_eq!(position.trade_ids.len(), 2);
4473        assert!(position.trade_ids.contains(&TradeId::from("T-1")));
4474        assert!(position.trade_ids.contains(&TradeId::from("T-2")));
4475
4476        position.try_apply(&fill_reopen).unwrap();
4477        position.try_apply(&fill_duplicate_open).unwrap();
4478
4479        assert_eq!(position.side, PositionSide::Long);
4480        assert_eq!(position.quantity, Quantity::from(5));
4481        assert_eq!(position.opening_order_id, ClientOrderId::from("O-3"));
4482        assert_eq!(position.events, vec![fill_reopen.clone()]);
4483        assert_eq!(position.replay_events.len(), 3);
4484        assert_eq!(position.trade_ids.len(), 1);
4485        assert!(position.trade_ids.contains(&TradeId::from("T-3")));
4486
4487        position
4488            .apply_fill_void(fill_voided, Quantity::from(10), None)
4489            .unwrap();
4490
4491        assert_eq!(position.side, PositionSide::Long);
4492        assert_eq!(position.quantity, Quantity::from(15));
4493        assert_eq!(position.opening_order_id, ClientOrderId::from("O-1"));
4494        assert_eq!(position.closing_order_id, None);
4495        assert_eq!(position.avg_px_open, dec!(1.0));
4496        assert_eq!(position.buy_qty, Quantity::from(15));
4497        assert_eq!(position.sell_qty, Quantity::from(0));
4498        assert_eq!(
4499            position.events,
4500            vec![fill_open.clone(), fill_reopen.clone()]
4501        );
4502        assert_eq!(position.replay_events.len(), 3);
4503        assert_eq!(position.fill_voids.len(), 1);
4504        assert_eq!(position.trade_ids.len(), 2);
4505        assert!(position.trade_ids.contains(&TradeId::from("T-1")));
4506        assert!(position.trade_ids.contains(&TradeId::from("T-3")));
4507
4508        let mut fill_close_duplicate = fill_close;
4509        fill_close_duplicate.event_id = uuid4();
4510        fill_close_duplicate.ts_event = UnixNanos::from(6);
4511        position.try_apply(&fill_close_duplicate).unwrap();
4512
4513        assert_eq!(position.side, PositionSide::Long);
4514        assert_eq!(position.quantity, Quantity::from(15));
4515        assert_eq!(position.events, vec![fill_open, fill_reopen]);
4516        assert_eq!(position.replay_events.len(), 3);
4517    }
4518
4519    #[rstest]
4520    fn test_replay_fill_with_foreign_causation_stays_duplicate(audusd_sim: CurrencyPair) {
4521        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
4522        let position_id = PositionId::from("P-CAUSATION");
4523        let fill_open = OrderFilledSpec::builder()
4524            .instrument_id(instrument.id())
4525            .client_order_id(ClientOrderId::from("O-1"))
4526            .trade_id(TradeId::from("T-1"))
4527            .order_side(OrderSide::Buy)
4528            .last_qty(Quantity::from(10))
4529            .last_px(Price::from("1.00000"))
4530            .currency(Currency::USD())
4531            .position_id(position_id)
4532            .ts_event(UnixNanos::from(1))
4533            .build();
4534        let fill_close = OrderFilledSpec::builder()
4535            .instrument_id(instrument.id())
4536            .client_order_id(ClientOrderId::from("O-2"))
4537            .trade_id(TradeId::from("T-2"))
4538            .order_side(OrderSide::Sell)
4539            .last_qty(Quantity::from(10))
4540            .last_px(Price::from("1.00000"))
4541            .currency(Currency::USD())
4542            .position_id(position_id)
4543            .ts_event(UnixNanos::from(2))
4544            .build();
4545        let mut position = Position::new(&instrument, fill_open.clone());
4546        position.apply(&fill_close);
4547
4548        let mut replayed = fill_open.clone();
4549        replayed.event_id = uuid4();
4550        replayed.ts_event = UnixNanos::from(3);
4551        replayed.causation_id = Some(fill_close.event_id);
4552
4553        position.apply(&replayed);
4554
4555        assert_eq!(position.side, PositionSide::Flat);
4556        assert_eq!(position.quantity, Quantity::from(0));
4557        assert_eq!(position.events, vec![fill_open, fill_close.clone()]);
4558    }
4559
4560    #[rstest]
4561    fn test_position_applies_fills_with_negative_prices(audusd_sim: CurrencyPair) {
4562        // Options and spreads can trade at negative prices; position average
4563        // price updates must not panic when the stored average or incoming
4564        // fill price is below zero.
4565        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
4566        let order = OrderTestBuilder::new(OrderType::Market)
4567            .instrument_id(audusd_sim.id())
4568            .side(OrderSide::Buy)
4569            .quantity(Quantity::from(100_000))
4570            .build();
4571        let fill1 = TestOrderEventStubs::filled(
4572            &order,
4573            &audusd_sim,
4574            Some(TradeId::new("1")),
4575            None,
4576            Some(Price::from("-5.00000")),
4577            Some(Quantity::from(50_000)),
4578            None,
4579            None,
4580            None,
4581            None,
4582        );
4583        let fill2 = TestOrderEventStubs::filled(
4584            &order,
4585            &audusd_sim,
4586            Some(TradeId::new("2")),
4587            None,
4588            Some(Price::from("-7.00000")),
4589            Some(Quantity::from(50_000)),
4590            None,
4591            None,
4592            None,
4593            None,
4594        );
4595        let mut position = Position::new(&audusd_sim, fill1.into());
4596        position.apply(&fill2.into());
4597
4598        assert_eq!(position.quantity, Quantity::from(100_000));
4599        assert_eq!(position.signed_qty, dec!(100_000.0));
4600        assert_eq!(position.side, PositionSide::Long);
4601        // Weighted avg_px_open: (50_000 * -5 + 50_000 * -7) / 100_000 = -6.0
4602        assert_eq!(position.avg_px_open, dec!(-6.0));
4603    }
4604
4605    #[rstest]
4606    fn test_position_filled_with_buy_order(audusd_sim: CurrencyPair) {
4607        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
4608        let order = OrderTestBuilder::new(OrderType::Market)
4609            .instrument_id(audusd_sim.id())
4610            .side(OrderSide::Buy)
4611            .quantity(Quantity::from(100_000))
4612            .build();
4613        let fill = TestOrderEventStubs::filled(
4614            &order,
4615            &audusd_sim,
4616            None,
4617            None,
4618            Some(Price::from("1.00001")),
4619            None,
4620            None,
4621            None,
4622            None,
4623            None,
4624        );
4625        let last_price = Price::from_str("1.0005").unwrap();
4626        let position = Position::new(&audusd_sim, fill.into());
4627        assert_eq!(position.symbol(), audusd_sim.id().symbol);
4628        assert_eq!(position.venue(), audusd_sim.id().venue);
4629        assert_eq!(position.closing_order_side(), Some(OrderSide::Sell));
4630        assert!(!position.is_opposite_side(OrderSide::Buy));
4631        assert_eq!(position, position); // equality operator test
4632        assert!(position.closing_order_id.is_none());
4633        assert_eq!(position.quantity, Quantity::from(100_000));
4634        assert_eq!(position.peak_qty, Quantity::from(100_000));
4635        assert_eq!(position.size_precision, 0);
4636        assert_eq!(position.signed_qty, dec!(100_000.0));
4637        assert_eq!(position.entry, OrderSide::Buy);
4638        assert_eq!(position.side, PositionSide::Long);
4639        assert_eq!(position.ts_opened.as_u64(), 0);
4640        assert_eq!(position.duration_ns, DurationNanos::default());
4641        assert_eq!(position.avg_px_open, dec!(1.00001));
4642        assert_eq!(position.event_count(), 1);
4643        assert_eq!(position.id, PositionId::new("1"));
4644        assert_eq!(position.events.len(), 1);
4645        assert!(position.is_long());
4646        assert!(!position.is_short());
4647        assert!(position.is_open());
4648        assert!(!position.is_closed());
4649        assert_eq!(position.realized_return, 0.0);
4650        assert_eq!(position.realized_pnl, Some(Money::from("-2.0 USD")));
4651        assert_eq!(
4652            position.unrealized_pnl(last_price).unwrap(),
4653            Money::from("49.0 USD")
4654        );
4655        assert_eq!(
4656            position.total_pnl(last_price).unwrap(),
4657            Money::from("47.0 USD")
4658        );
4659        assert_eq!(position.commissions(), vec![Money::from("2.0 USD")]);
4660        assert_eq!(
4661            format!("{position}"),
4662            "Position(LONG 100_000 AUD/USD.SIM, id=1)"
4663        );
4664    }
4665
4666    #[rstest]
4667    fn test_position_filled_with_sell_order(audusd_sim: CurrencyPair) {
4668        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
4669        let order = OrderTestBuilder::new(OrderType::Market)
4670            .instrument_id(audusd_sim.id())
4671            .side(OrderSide::Sell)
4672            .quantity(Quantity::from(100_000))
4673            .build();
4674        let fill = TestOrderEventStubs::filled(
4675            &order,
4676            &audusd_sim,
4677            None,
4678            None,
4679            Some(Price::from("1.00001")),
4680            None,
4681            None,
4682            None,
4683            None,
4684            None,
4685        );
4686        let last_price = Price::from_str("1.00050").unwrap();
4687        let position = Position::new(&audusd_sim, fill.into());
4688        assert_eq!(position.symbol(), audusd_sim.id().symbol);
4689        assert_eq!(position.venue(), audusd_sim.id().venue);
4690        assert_eq!(position.closing_order_side(), Some(OrderSide::Buy));
4691        assert!(!position.is_opposite_side(OrderSide::Sell));
4692        assert_eq!(position, position); // Equality operator test
4693        assert!(position.closing_order_id.is_none());
4694        assert_eq!(position.quantity, Quantity::from(100_000));
4695        assert_eq!(position.peak_qty, Quantity::from(100_000));
4696        assert_eq!(position.signed_qty, dec!(-100_000.0));
4697        assert_eq!(position.entry, OrderSide::Sell);
4698        assert_eq!(position.side, PositionSide::Short);
4699        assert_eq!(position.ts_opened.as_u64(), 0);
4700        assert_eq!(position.avg_px_open, dec!(1.00001));
4701        assert_eq!(position.event_count(), 1);
4702        assert_eq!(position.id, PositionId::new("1"));
4703        assert_eq!(position.events.len(), 1);
4704        assert!(!position.is_long());
4705        assert!(position.is_short());
4706        assert!(position.is_open());
4707        assert!(!position.is_closed());
4708        assert_eq!(position.realized_return, 0.0);
4709        assert_eq!(position.realized_pnl, Some(Money::from("-2.0 USD")));
4710        assert_eq!(
4711            position.unrealized_pnl(last_price).unwrap(),
4712            Money::from("-49.0 USD")
4713        );
4714        assert_eq!(
4715            position.total_pnl(last_price).unwrap(),
4716            Money::from("-51.0 USD")
4717        );
4718        assert_eq!(position.commissions(), vec![Money::from("2.0 USD")]);
4719        assert_eq!(
4720            format!("{position}"),
4721            "Position(SHORT 100_000 AUD/USD.SIM, id=1)"
4722        );
4723    }
4724
4725    #[rstest]
4726    fn test_position_partial_fills_with_buy_order(audusd_sim: CurrencyPair) {
4727        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
4728        let order = OrderTestBuilder::new(OrderType::Market)
4729            .instrument_id(audusd_sim.id())
4730            .side(OrderSide::Buy)
4731            .quantity(Quantity::from(100_000))
4732            .build();
4733        let fill = TestOrderEventStubs::filled(
4734            &order,
4735            &audusd_sim,
4736            None,
4737            None,
4738            Some(Price::from("1.00001")),
4739            Some(Quantity::from(50_000)),
4740            None,
4741            None,
4742            None,
4743            None,
4744        );
4745        let last_price = Price::from_str("1.00048").unwrap();
4746        let position = Position::new(&audusd_sim, fill.into());
4747        assert_eq!(position.quantity, Quantity::from(50_000));
4748        assert_eq!(position.peak_qty, Quantity::from(50_000));
4749        assert_eq!(position.side, PositionSide::Long);
4750        assert_eq!(position.signed_qty, dec!(50000.0));
4751        assert_eq!(position.avg_px_open, dec!(1.00001));
4752        assert_eq!(position.event_count(), 1);
4753        assert_eq!(position.ts_opened.as_u64(), 0);
4754        assert!(position.is_long());
4755        assert!(!position.is_short());
4756        assert!(position.is_open());
4757        assert!(!position.is_closed());
4758        assert_eq!(position.realized_return, 0.0);
4759        assert_eq!(position.realized_pnl, Some(Money::from("-2.0 USD")));
4760        assert_eq!(
4761            position.unrealized_pnl(last_price).unwrap(),
4762            Money::from("23.5 USD")
4763        );
4764        assert_eq!(
4765            position.total_pnl(last_price).unwrap(),
4766            Money::from("21.5 USD")
4767        );
4768        assert_eq!(position.commissions(), vec![Money::from("2.0 USD")]);
4769        assert_eq!(
4770            format!("{position}"),
4771            "Position(LONG 50_000 AUD/USD.SIM, id=1)"
4772        );
4773    }
4774
4775    #[rstest]
4776    fn test_position_partial_fills_with_two_sell_orders(audusd_sim: CurrencyPair) {
4777        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
4778        let order = OrderTestBuilder::new(OrderType::Market)
4779            .instrument_id(audusd_sim.id())
4780            .side(OrderSide::Sell)
4781            .quantity(Quantity::from(100_000))
4782            .build();
4783        let fill1 = TestOrderEventStubs::filled(
4784            &order,
4785            &audusd_sim,
4786            Some(TradeId::new("1")),
4787            None,
4788            Some(Price::from("1.00001")),
4789            Some(Quantity::from(50_000)),
4790            None,
4791            None,
4792            None,
4793            None,
4794        );
4795        let fill2 = TestOrderEventStubs::filled(
4796            &order,
4797            &audusd_sim,
4798            Some(TradeId::new("2")),
4799            None,
4800            Some(Price::from("1.00002")),
4801            Some(Quantity::from(50_000)),
4802            None,
4803            None,
4804            None,
4805            None,
4806        );
4807        let last_price = Price::from_str("1.0005").unwrap();
4808        let mut position = Position::new(&audusd_sim, fill1.into());
4809        position.apply(&fill2.into());
4810
4811        assert_eq!(position.quantity, Quantity::from(100_000));
4812        assert_eq!(position.peak_qty, Quantity::from(100_000));
4813        assert_eq!(position.side, PositionSide::Short);
4814        assert_eq!(position.signed_qty, dec!(-100_000.0));
4815        assert_eq!(position.avg_px_open, dec!(1.000_015));
4816        assert_eq!(position.event_count(), 2);
4817        assert_eq!(position.ts_opened, 0);
4818        assert!(position.is_short());
4819        assert!(!position.is_long());
4820        assert!(position.is_open());
4821        assert!(!position.is_closed());
4822        assert_eq!(position.realized_return, 0.0);
4823        assert_eq!(position.realized_pnl, Some(Money::from("-4.0 USD")));
4824        assert_eq!(
4825            position.unrealized_pnl(last_price).unwrap(),
4826            Money::from("-48.5 USD")
4827        );
4828        assert_eq!(
4829            position.total_pnl(last_price).unwrap(),
4830            Money::from("-52.5 USD")
4831        );
4832        assert_eq!(position.commissions(), vec![Money::from("4.0 USD")]);
4833    }
4834
4835    #[rstest]
4836    pub fn test_position_filled_with_buy_order_then_sell_order(audusd_sim: CurrencyPair) {
4837        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
4838        let order = OrderTestBuilder::new(OrderType::Market)
4839            .instrument_id(audusd_sim.id())
4840            .side(OrderSide::Buy)
4841            .quantity(Quantity::from(150_000))
4842            .build();
4843        let fill = TestOrderEventStubs::filled(
4844            &order,
4845            &audusd_sim,
4846            Some(TradeId::new("1")),
4847            Some(PositionId::new("P-1")),
4848            Some(Price::from("1.00001")),
4849            None,
4850            None,
4851            None,
4852            Some(UnixNanos::from(1_000_000_000)),
4853            None,
4854        );
4855        let mut position = Position::new(&audusd_sim, fill.into());
4856
4857        let fill2 = OrderFilledSpec::builder()
4858            .trader_id(order.trader_id())
4859            .strategy_id(StrategyId::new("S-001"))
4860            .instrument_id(order.instrument_id())
4861            .client_order_id(order.client_order_id())
4862            .venue_order_id(VenueOrderId::from("2"))
4863            .account_id(order.account_id().unwrap_or(AccountId::new("SIM-001")))
4864            .trade_id(TradeId::new("2"))
4865            .order_side(OrderSide::Sell)
4866            .last_qty(order.quantity())
4867            .last_px(Price::from("1.00011"))
4868            .currency(audusd_sim.quote_currency())
4869            .ts_event(2_000_000_000.into())
4870            .position_id(PositionId::new("T1"))
4871            .commission(Money::from("0.0 USD"))
4872            .build();
4873        position.apply(&fill2);
4874        let last = Price::from_str("1.0005").unwrap();
4875
4876        assert!(position.is_opposite_side(fill2.order_side));
4877        assert_eq!(
4878            position.quantity,
4879            Quantity::zero(audusd_sim.price_precision())
4880        );
4881        assert_eq!(position.size_precision, 0);
4882        assert_eq!(position.signed_qty, dec!(0.0));
4883        assert_eq!(position.side, PositionSide::Flat);
4884        assert_eq!(position.ts_opened, 1_000_000_000);
4885        assert_eq!(position.ts_closed, Some(UnixNanos::from(2_000_000_000)));
4886        assert_eq!(position.duration_ns, DurationNanos::from_secs(1));
4887        assert_eq!(position.avg_px_open, dec!(1.00001));
4888        assert_eq!(position.avg_px_close, Some(dec!(1.00011)));
4889        assert!(!position.is_long());
4890        assert!(!position.is_short());
4891        assert!(!position.is_open());
4892        assert!(position.is_closed());
4893        assert_eq!(position.realized_return, (1.00011_f64 - 1.00001) / 1.00001);
4894        assert_eq!(position.realized_pnl, Some(Money::from("13.0 USD")));
4895        assert_eq!(position.unrealized_pnl(last).unwrap(), Money::from("0 USD"));
4896        assert_eq!(position.commissions(), vec![Money::from("2 USD")]);
4897        assert_eq!(position.total_pnl(last).unwrap(), Money::from("13 USD"));
4898        assert_eq!(format!("{position}"), "Position(FLAT AUD/USD.SIM, id=P-1)");
4899    }
4900
4901    #[rstest]
4902    pub fn test_position_filled_with_sell_order_then_buy_order(audusd_sim: CurrencyPair) {
4903        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
4904        let order1 = OrderTestBuilder::new(OrderType::Market)
4905            .instrument_id(audusd_sim.id())
4906            .side(OrderSide::Sell)
4907            .quantity(Quantity::from(100_000))
4908            .build();
4909        let order2 = OrderTestBuilder::new(OrderType::Market)
4910            .instrument_id(audusd_sim.id())
4911            .side(OrderSide::Buy)
4912            .quantity(Quantity::from(100_000))
4913            .build();
4914        let fill1 = TestOrderEventStubs::filled(
4915            &order1,
4916            &audusd_sim,
4917            None,
4918            Some(PositionId::new("P-19700101-000000-001-001-1")),
4919            Some(Price::from("1.0")),
4920            None,
4921            None,
4922            None,
4923            None,
4924            None,
4925        );
4926        let mut position = Position::new(&audusd_sim, fill1.into());
4927        // create closing from order from different venue but same strategy
4928        let fill2 = TestOrderEventStubs::filled(
4929            &order2,
4930            &audusd_sim,
4931            Some(TradeId::new("1")),
4932            Some(PositionId::new("P-19700101-000000-001-001-1")),
4933            Some(Price::from("1.00001")),
4934            Some(Quantity::from(50_000)),
4935            None,
4936            None,
4937            None,
4938            None,
4939        );
4940        let fill3 = TestOrderEventStubs::filled(
4941            &order2,
4942            &audusd_sim,
4943            Some(TradeId::new("2")),
4944            Some(PositionId::new("P-19700101-000000-001-001-1")),
4945            Some(Price::from("1.00003")),
4946            Some(Quantity::from(50_000)),
4947            None,
4948            None,
4949            None,
4950            None,
4951        );
4952        let last = Price::from("1.0005");
4953        position.apply(&fill2.into());
4954        position.apply(&fill3.into());
4955
4956        assert_eq!(
4957            position.quantity,
4958            Quantity::zero(audusd_sim.price_precision())
4959        );
4960        assert_eq!(position.side, PositionSide::Flat);
4961        assert_eq!(position.ts_opened, 0);
4962        assert_eq!(position.avg_px_open, dec!(1.0));
4963        assert_eq!(position.events.len(), 3);
4964        assert_eq!(position.ts_closed, Some(UnixNanos::default()));
4965        assert_eq!(position.avg_px_close, Some(dec!(1.00002)));
4966        assert!(!position.is_long());
4967        assert!(!position.is_short());
4968        assert!(!position.is_open());
4969        assert!(position.is_closed());
4970        assert_eq!(position.commissions(), vec![Money::from("6.0 USD")]);
4971        assert_eq!(position.unrealized_pnl(last).unwrap(), Money::from("0 USD"));
4972        assert_eq!(position.realized_pnl, Some(Money::from("-8.0 USD")));
4973        assert_eq!(position.total_pnl(last).unwrap(), Money::from("-8.0 USD"));
4974        assert_eq!(
4975            format!("{position}"),
4976            "Position(FLAT AUD/USD.SIM, id=P-19700101-000000-001-001-1)"
4977        );
4978    }
4979
4980    #[rstest]
4981    fn test_position_filled_with_no_change(audusd_sim: CurrencyPair) {
4982        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
4983        let order1 = OrderTestBuilder::new(OrderType::Market)
4984            .instrument_id(audusd_sim.id())
4985            .side(OrderSide::Buy)
4986            .quantity(Quantity::from(100_000))
4987            .build();
4988        let order2 = OrderTestBuilder::new(OrderType::Market)
4989            .instrument_id(audusd_sim.id())
4990            .side(OrderSide::Sell)
4991            .quantity(Quantity::from(100_000))
4992            .build();
4993        let fill1 = TestOrderEventStubs::filled(
4994            &order1,
4995            &audusd_sim,
4996            Some(TradeId::new("1")),
4997            Some(PositionId::new("P-19700101-000000-001-001-1")),
4998            Some(Price::from("1.0")),
4999            None,
5000            None,
5001            None,
5002            None,
5003            None,
5004        );
5005        let mut position = Position::new(&audusd_sim, fill1.into());
5006        let fill2 = TestOrderEventStubs::filled(
5007            &order2,
5008            &audusd_sim,
5009            Some(TradeId::new("2")),
5010            Some(PositionId::new("P-19700101-000000-001-001-1")),
5011            Some(Price::from("1.0")),
5012            None,
5013            None,
5014            None,
5015            None,
5016            None,
5017        );
5018        let last = Price::from("1.0005");
5019        position.apply(&fill2.into());
5020
5021        assert_eq!(
5022            position.quantity,
5023            Quantity::zero(audusd_sim.price_precision())
5024        );
5025        assert_eq!(position.closing_order_side(), None);
5026        assert_eq!(position.side, PositionSide::Flat);
5027        assert_eq!(position.ts_opened, 0);
5028        assert_eq!(position.avg_px_open, dec!(1.0));
5029        assert_eq!(position.events.len(), 2);
5030        // assert_eq!(position.trade_ids, vec![fill1.trade_id, fill2.trade_id]);  // TODO
5031        assert_eq!(position.ts_closed, Some(UnixNanos::default()));
5032        assert_eq!(position.avg_px_close, Some(dec!(1.0)));
5033        assert!(!position.is_long());
5034        assert!(!position.is_short());
5035        assert!(!position.is_open());
5036        assert!(position.is_closed());
5037        assert_eq!(position.commissions(), vec![Money::from("4.0 USD")]);
5038        assert_eq!(position.unrealized_pnl(last).unwrap(), Money::from("0 USD"));
5039        assert_eq!(position.realized_pnl, Some(Money::from("-4.0 USD")));
5040        assert_eq!(position.total_pnl(last).unwrap(), Money::from("-4.0 USD"));
5041        assert_eq!(
5042            format!("{position}"),
5043            "Position(FLAT AUD/USD.SIM, id=P-19700101-000000-001-001-1)"
5044        );
5045    }
5046
5047    #[rstest]
5048    fn test_position_long_with_multiple_filled_orders(audusd_sim: CurrencyPair) {
5049        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
5050        let order1 = OrderTestBuilder::new(OrderType::Market)
5051            .instrument_id(audusd_sim.id())
5052            .side(OrderSide::Buy)
5053            .quantity(Quantity::from(100_000))
5054            .build();
5055        let order2 = OrderTestBuilder::new(OrderType::Market)
5056            .instrument_id(audusd_sim.id())
5057            .side(OrderSide::Buy)
5058            .quantity(Quantity::from(100_000))
5059            .build();
5060        let order3 = OrderTestBuilder::new(OrderType::Market)
5061            .instrument_id(audusd_sim.id())
5062            .side(OrderSide::Sell)
5063            .quantity(Quantity::from(200_000))
5064            .build();
5065        let fill1 = TestOrderEventStubs::filled(
5066            &order1,
5067            &audusd_sim,
5068            Some(TradeId::new("1")),
5069            Some(PositionId::new("P-123456")),
5070            Some(Price::from("1.0")),
5071            None,
5072            None,
5073            None,
5074            None,
5075            None,
5076        );
5077        let fill2 = TestOrderEventStubs::filled(
5078            &order2,
5079            &audusd_sim,
5080            Some(TradeId::new("2")),
5081            Some(PositionId::new("P-123456")),
5082            Some(Price::from("1.00001")),
5083            None,
5084            None,
5085            None,
5086            None,
5087            None,
5088        );
5089        let fill3 = TestOrderEventStubs::filled(
5090            &order3,
5091            &audusd_sim,
5092            Some(TradeId::new("3")),
5093            Some(PositionId::new("P-123456")),
5094            Some(Price::from("1.0001")),
5095            None,
5096            None,
5097            None,
5098            None,
5099            None,
5100        );
5101        let mut position = Position::new(&audusd_sim, fill1.into());
5102        let last = Price::from("1.0005");
5103        position.apply(&fill2.into());
5104        position.apply(&fill3.into());
5105
5106        assert_eq!(
5107            position.quantity,
5108            Quantity::zero(audusd_sim.price_precision())
5109        );
5110        assert_eq!(position.side, PositionSide::Flat);
5111        assert_eq!(position.ts_opened, 0);
5112        assert_eq!(position.avg_px_open, dec!(1.000_005));
5113        assert_eq!(position.events.len(), 3);
5114        // assert_eq!(
5115        //     position.trade_ids,
5116        //     vec![fill1.trade_id, fill2.trade_id, fill3.trade_id]
5117        // );
5118        assert_eq!(position.ts_closed, Some(UnixNanos::default()));
5119        assert_eq!(position.avg_px_close, Some(dec!(1.0001)));
5120        assert!(position.is_closed());
5121        assert!(!position.is_open());
5122        assert!(!position.is_long());
5123        assert!(!position.is_short());
5124        assert_eq!(position.commissions(), vec![Money::from("6.0 USD")]);
5125        assert_eq!(position.realized_pnl, Some(Money::from("13.0 USD")));
5126        assert_eq!(position.unrealized_pnl(last).unwrap(), Money::from("0 USD"));
5127        assert_eq!(position.total_pnl(last).unwrap(), Money::from("13 USD"));
5128        assert_eq!(
5129            format!("{position}"),
5130            "Position(FLAT AUD/USD.SIM, id=P-123456)"
5131        );
5132    }
5133
5134    #[rstest]
5135    fn test_pnl_calculation_from_trading_technologies_example(currency_pair_ethusdt: CurrencyPair) {
5136        let ethusdt = InstrumentAny::CurrencyPair(currency_pair_ethusdt);
5137        let quantity1 = Quantity::from(12);
5138        let price1 = Price::from("100.0");
5139        let order1 = OrderTestBuilder::new(OrderType::Market)
5140            .instrument_id(ethusdt.id())
5141            .side(OrderSide::Buy)
5142            .quantity(quantity1)
5143            .build();
5144        let commission1 =
5145            calculate_commission(&ethusdt, order1.quantity(), price1, None, dec!(0.0001));
5146        let fill1 = TestOrderEventStubs::filled(
5147            &order1,
5148            &ethusdt,
5149            Some(TradeId::new("1")),
5150            Some(PositionId::new("P-123456")),
5151            Some(price1),
5152            None,
5153            None,
5154            Some(commission1),
5155            None,
5156            None,
5157        );
5158        let mut position = Position::new(&ethusdt, fill1.into());
5159        let quantity2 = Quantity::from(17);
5160        let order2 = OrderTestBuilder::new(OrderType::Market)
5161            .instrument_id(ethusdt.id())
5162            .side(OrderSide::Buy)
5163            .quantity(quantity2)
5164            .build();
5165        let price2 = Price::from("99.0");
5166        let commission2 =
5167            calculate_commission(&ethusdt, order2.quantity(), price2, None, dec!(0.0001));
5168        let fill2 = TestOrderEventStubs::filled(
5169            &order2,
5170            &ethusdt,
5171            Some(TradeId::new("2")),
5172            Some(PositionId::new("P-123456")),
5173            Some(price2),
5174            None,
5175            None,
5176            Some(commission2),
5177            None,
5178            None,
5179        );
5180        position.apply(&fill2.into());
5181        assert_eq!(position.quantity, Quantity::from(29));
5182        assert_eq!(position.realized_pnl, Some(Money::from("-0.28830000 USDT")));
5183        assert_eq!(position.avg_px_open, (dec!(2883) / dec!(29)));
5184        let quantity3 = Quantity::from(9);
5185        let order3 = OrderTestBuilder::new(OrderType::Market)
5186            .instrument_id(ethusdt.id())
5187            .side(OrderSide::Sell)
5188            .quantity(quantity3)
5189            .build();
5190        let price3 = Price::from("101.0");
5191        let commission3 =
5192            calculate_commission(&ethusdt, order3.quantity(), price3, None, dec!(0.0001));
5193        let fill3 = TestOrderEventStubs::filled(
5194            &order3,
5195            &ethusdt,
5196            Some(TradeId::new("3")),
5197            Some(PositionId::new("P-123456")),
5198            Some(price3),
5199            None,
5200            None,
5201            Some(commission3),
5202            None,
5203            None,
5204        );
5205        position.apply(&fill3.into());
5206        assert_eq!(position.quantity, Quantity::from(20));
5207        assert_eq!(
5208            position.realized_pnl,
5209            Some(native_money(dec!(251877) / dec!(18125), Currency::USDT()))
5210        );
5211        assert_eq!(position.avg_px_open, (dec!(2883) / dec!(29)));
5212        let quantity4 = Quantity::from("4");
5213        let price4 = Price::from("105.0");
5214        let order4 = OrderTestBuilder::new(OrderType::Market)
5215            .instrument_id(ethusdt.id())
5216            .side(OrderSide::Sell)
5217            .quantity(quantity4)
5218            .build();
5219        let commission4 =
5220            calculate_commission(&ethusdt, order4.quantity(), price4, None, dec!(0.0001));
5221        let fill4 = TestOrderEventStubs::filled(
5222            &order4,
5223            &ethusdt,
5224            Some(TradeId::new("4")),
5225            Some(PositionId::new("P-123456")),
5226            Some(price4),
5227            None,
5228            None,
5229            Some(commission4),
5230            None,
5231            None,
5232        );
5233        position.apply(&fill4.into());
5234        assert_eq!(position.quantity, Quantity::from("16"));
5235        assert_eq!(
5236            position.realized_pnl,
5237            Some(native_money(dec!(2624463) / dec!(72500), Currency::USDT()))
5238        );
5239        assert_eq!(position.avg_px_open, (dec!(2883) / dec!(29)));
5240        let quantity5 = Quantity::from("3");
5241        let price5 = Price::from("103.0");
5242        let order5 = OrderTestBuilder::new(OrderType::Market)
5243            .instrument_id(ethusdt.id())
5244            .side(OrderSide::Buy)
5245            .quantity(quantity5)
5246            .build();
5247        let commission5 =
5248            calculate_commission(&ethusdt, order5.quantity(), price5, None, dec!(0.0001));
5249        let fill5 = TestOrderEventStubs::filled(
5250            &order5,
5251            &ethusdt,
5252            Some(TradeId::new("5")),
5253            Some(PositionId::new("P-123456")),
5254            Some(price5),
5255            None,
5256            None,
5257            Some(commission5),
5258            None,
5259            None,
5260        );
5261        position.apply(&fill5.into());
5262        assert_eq!(position.quantity, Quantity::from("19"));
5263        assert_eq!(
5264            position.realized_pnl,
5265            Some(native_money(
5266                dec!(10488891) / dec!(290000),
5267                Currency::USDT()
5268            ))
5269        );
5270        assert_eq!(position.avg_px_open, dec!(99.98003629764065335753176043));
5271        assert_eq!(
5272            format!("{position}"),
5273            "Position(LONG 19.00000 ETHUSDT.BINANCE, id=P-123456)"
5274        );
5275    }
5276
5277    #[rstest]
5278    fn test_position_closed_and_reopened(audusd_sim: CurrencyPair) {
5279        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
5280        let quantity1 = Quantity::from(150_000);
5281        let price1 = Price::from("1.00001");
5282        let order = OrderTestBuilder::new(OrderType::Market)
5283            .instrument_id(audusd_sim.id())
5284            .side(OrderSide::Buy)
5285            .quantity(quantity1)
5286            .build();
5287        let commission1 = calculate_commission(&audusd_sim, quantity1, price1, None, dec!(0.00002));
5288        let fill1 = TestOrderEventStubs::filled(
5289            &order,
5290            &audusd_sim,
5291            Some(TradeId::new("5")),
5292            Some(PositionId::new("P-123456")),
5293            Some(Price::from("1.00001")),
5294            None,
5295            None,
5296            Some(commission1),
5297            Some(UnixNanos::from(1_000_000_000)),
5298            None,
5299        );
5300        let mut position = Position::new(&audusd_sim, fill1.into());
5301
5302        let fill2 = OrderFilledSpec::builder()
5303            .trader_id(order.trader_id())
5304            .strategy_id(order.strategy_id())
5305            .instrument_id(order.instrument_id())
5306            .client_order_id(order.client_order_id())
5307            .venue_order_id(VenueOrderId::from("2"))
5308            .account_id(order.account_id().unwrap_or(AccountId::new("SIM-001")))
5309            .trade_id(TradeId::from("2"))
5310            .order_side(OrderSide::Sell)
5311            .last_qty(order.quantity())
5312            .last_px(Price::from("1.00011"))
5313            .currency(audusd_sim.quote_currency())
5314            .ts_event(UnixNanos::from(2_000_000_000))
5315            .position_id(PositionId::from("P-123456"))
5316            .commission(Money::from("0 USD"))
5317            .build();
5318
5319        position.apply(&fill2);
5320
5321        let fill3 = OrderFilledSpec::builder()
5322            .trader_id(order.trader_id())
5323            .strategy_id(order.strategy_id())
5324            .instrument_id(order.instrument_id())
5325            .client_order_id(order.client_order_id())
5326            .venue_order_id(VenueOrderId::from("2"))
5327            .account_id(order.account_id().unwrap_or(AccountId::new("SIM-001")))
5328            .trade_id(TradeId::from("3"))
5329            .last_qty(order.quantity())
5330            .last_px(Price::from("1.00012"))
5331            .currency(audusd_sim.quote_currency())
5332            .ts_event(UnixNanos::from(3_000_000_000))
5333            .position_id(PositionId::from("P-123456"))
5334            .commission(Money::from("0 USD"))
5335            .build();
5336
5337        position.apply(&fill3);
5338
5339        let last = Price::from("1.0003");
5340        assert!(position.is_opposite_side(fill2.order_side));
5341        assert_eq!(position.quantity, Quantity::from(150_000));
5342        assert_eq!(position.peak_qty, Quantity::from(150_000));
5343        assert_eq!(position.side, PositionSide::Long);
5344        assert_eq!(position.opening_order_id, fill3.client_order_id);
5345        assert_eq!(position.closing_order_id, None);
5346        assert_eq!(position.ts_opened, 3_000_000_000);
5347        assert_eq!(position.duration_ns, DurationNanos::default());
5348        assert_eq!(position.avg_px_open, dec!(1.00012));
5349        assert_eq!(position.event_count(), 1);
5350        assert_eq!(position.ts_closed, None);
5351        assert_eq!(position.avg_px_close, None);
5352        assert!(position.is_long());
5353        assert!(!position.is_short());
5354        assert!(position.is_open());
5355        assert!(!position.is_closed());
5356        assert_eq!(position.realized_return, 0.0);
5357        assert_eq!(position.realized_pnl, Some(Money::from("0 USD")));
5358        assert_eq!(
5359            position.unrealized_pnl(last).unwrap(),
5360            Money::from("27 USD")
5361        );
5362        assert_eq!(position.total_pnl(last).unwrap(), Money::from("27 USD"));
5363        assert_eq!(position.commissions(), vec![Money::from("0 USD")]);
5364        assert_eq!(
5365            format!("{position}"),
5366            "Position(LONG 150_000 AUD/USD.SIM, id=P-123456)"
5367        );
5368    }
5369
5370    #[rstest]
5371    #[case::zero(Quantity::from(0))]
5372    #[case::exceeds_fragments(Quantity::from(11))]
5373    fn test_apply_fill_void_rejects_invalid_allocation_without_mutation(
5374        #[case] voided_qty: Quantity,
5375        audusd_sim: CurrencyPair,
5376    ) {
5377        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
5378        let position_id = PositionId::from("P-VOID-INVALID");
5379        let fill = OrderFilledSpec::builder()
5380            .instrument_id(instrument.id())
5381            .client_order_id(ClientOrderId::from("O-VOID-INVALID"))
5382            .trade_id(TradeId::from("T-VOID-INVALID"))
5383            .order_side(OrderSide::Buy)
5384            .last_qty(Quantity::from(10))
5385            .last_px(Price::from("1.00000"))
5386            .currency(Currency::USD())
5387            .position_id(position_id)
5388            .build();
5389        let fill_voided = matching_fill_void(&fill, voided_qty, None);
5390        let mut position = Position::new(&instrument, fill);
5391        let state_before = serde_json::to_value(&position).unwrap();
5392
5393        let error = position
5394            .apply_fill_void(fill_voided, voided_qty, None)
5395            .unwrap_err();
5396
5397        assert_eq!(
5398            error.to_string(),
5399            "position fill void exceeds known fragments for T-VOID-INVALID"
5400        );
5401        assert_eq!(serde_json::to_value(&position).unwrap(), state_before);
5402    }
5403
5404    #[rstest]
5405    #[case::stale(
5406        Quantity::from(4),
5407        Money::from("0.40 USD"),
5408        "stale position fill void for T-VOID-CUMULATIVE"
5409    )]
5410    #[case::duplicate(
5411        Quantity::from(5),
5412        Money::from("0.50 USD"),
5413        "duplicate position fill void for T-VOID-CUMULATIVE"
5414    )]
5415    fn test_apply_fill_void_rejects_invalid_cumulative_update_without_mutation(
5416        #[case] voided_qty: Quantity,
5417        #[case] commission_voided: Money,
5418        #[case] expected_error: &str,
5419        audusd_sim: CurrencyPair,
5420    ) {
5421        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
5422        let position_id = PositionId::from("P-VOID-CUMULATIVE");
5423        let fill = OrderFilledSpec::builder()
5424            .instrument_id(instrument.id())
5425            .client_order_id(ClientOrderId::from("O-VOID-CUMULATIVE"))
5426            .trade_id(TradeId::from("T-VOID-CUMULATIVE"))
5427            .order_side(OrderSide::Buy)
5428            .last_qty(Quantity::from(10))
5429            .last_px(Price::from("1.00000"))
5430            .currency(Currency::USD())
5431            .position_id(position_id)
5432            .commission(Money::from("1.00 USD"))
5433            .build();
5434        let fill_voided =
5435            matching_fill_void(&fill, Quantity::from(5), Some(Money::from("0.50 USD")));
5436        let mut position = Position::new(&instrument, fill);
5437        position
5438            .apply_fill_void(
5439                fill_voided.clone(),
5440                Quantity::from(5),
5441                Some(Money::from("0.50 USD")),
5442            )
5443            .unwrap();
5444        let state_before = serde_json::to_value(&position).unwrap();
5445
5446        let error = position
5447            .apply_fill_void(fill_voided, voided_qty, Some(commission_voided))
5448            .unwrap_err();
5449
5450        assert_eq!(error.to_string(), expected_error);
5451        assert_eq!(serde_json::to_value(&position).unwrap(), state_before);
5452    }
5453
5454    #[rstest]
5455    fn test_apply_fill_void_rejects_currency_mismatch_without_mutation(audusd_sim: CurrencyPair) {
5456        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
5457        let fill = OrderFilledSpec::builder()
5458            .instrument_id(instrument.id())
5459            .client_order_id(ClientOrderId::from("O-VOID-CURRENCY"))
5460            .trade_id(TradeId::from("T-VOID-CURRENCY"))
5461            .order_side(OrderSide::Buy)
5462            .last_qty(Quantity::from(10))
5463            .last_px(Price::from("1.00000"))
5464            .currency(Currency::USD())
5465            .position_id(PositionId::from("P-VOID-CURRENCY"))
5466            .commission(Money::from("1.00 USD"))
5467            .build();
5468        let commission_voided = Some(Money::from("0.50 EUR"));
5469        let voided_qty = Quantity::from(5);
5470        let fill_voided = matching_fill_void(&fill, voided_qty, commission_voided);
5471
5472        let mut position = Position::new(&instrument, fill);
5473        let before = serde_json::to_value(&position).unwrap();
5474        let error = position
5475            .apply_fill_void(fill_voided, voided_qty, commission_voided)
5476            .unwrap_err();
5477        assert_eq!(
5478            error.to_string(),
5479            "position commission currency differs for fill T-VOID-CURRENCY"
5480        );
5481        assert_eq!(serde_json::to_value(&position).unwrap(), before);
5482    }
5483
5484    #[rstest]
5485    fn test_apply_fill_void_uses_latest_cumulative_commission(audusd_sim: CurrencyPair) {
5486        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
5487        let position_id = PositionId::from("P-VOID-LATEST");
5488        let fill = OrderFilledSpec::builder()
5489            .instrument_id(instrument.id())
5490            .client_order_id(ClientOrderId::from("O-VOID-LATEST"))
5491            .trade_id(TradeId::from("T-VOID-LATEST"))
5492            .order_side(OrderSide::Buy)
5493            .last_qty(Quantity::from(10))
5494            .last_px(Price::from("1.00000"))
5495            .currency(Currency::USD())
5496            .position_id(position_id)
5497            .commission(Money::from("1.00 USD"))
5498            .build();
5499        let fill_voided =
5500            matching_fill_void(&fill, Quantity::from(4), Some(Money::from("0.40 USD")));
5501        let mut position = Position::new(&instrument, fill);
5502        position
5503            .apply_fill_void(
5504                fill_voided.clone(),
5505                Quantity::from(4),
5506                Some(Money::from("0.40 USD")),
5507            )
5508            .unwrap();
5509
5510        position
5511            .apply_fill_void(fill_voided, Quantity::from(7), None)
5512            .unwrap();
5513
5514        assert_eq!(position.side, PositionSide::Long);
5515        assert_eq!(position.quantity, Quantity::from(3));
5516        assert_eq!(position.commissions(), vec![Money::from("1.00 USD")]);
5517        assert_eq!(position.realized_pnl, Some(Money::from("-1.00 USD")));
5518        assert_eq!(position.fill_voids.len(), 2);
5519    }
5520
5521    #[cfg(feature = "defi")]
5522    #[rstest]
5523    #[case::native_instrument(0, "1.000000000000000001", "0.5", "0.500000000000000001")]
5524    #[case::wei_instrument(18, "1", "0.500000000000000001", "0.499999999999999999")]
5525    fn test_fill_void_accepts_mixed_qty_scales(
5526        mut audusd_sim: CurrencyPair,
5527        #[case] precision: u8,
5528        #[case] qty: &str,
5529        #[case] voided: &str,
5530        #[case] remaining: &str,
5531    ) {
5532        audusd_sim.size_precision = precision;
5533        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
5534        let fill = OrderFilledSpec::builder()
5535            .instrument_id(instrument.id())
5536            .last_qty(Quantity::from(qty))
5537            .last_px(Price::from("1"))
5538            .position_id(PositionId::from("P-MIXED-VOID"))
5539            .commission(Money::zero(Currency::USD()))
5540            .build();
5541        let mut position = Position::new(&instrument, fill.clone());
5542        let voided_qty = Quantity::from(voided);
5543        let first = matching_fill_void(&fill, voided_qty, None);
5544        position.apply_fill_void(first, voided_qty, None).unwrap();
5545
5546        assert_eq!(position.quantity, Quantity::from(remaining));
5547        assert_eq!(position.signed_qty, remaining.parse::<Decimal>().unwrap());
5548        assert_eq!(position.cost_open, remaining.parse::<Decimal>().unwrap());
5549        assert_eq!(position.realized_pnl, Some(Money::zero(Currency::USD())));
5550
5551        let final_void = matching_fill_void(&fill, fill.last_qty, None);
5552        position
5553            .apply_fill_void(final_void, fill.last_qty, None)
5554            .unwrap();
5555
5556        assert_eq!(position.quantity.as_decimal(), Decimal::ZERO);
5557        assert_eq!(position.signed_qty, Decimal::ZERO);
5558        assert_eq!(position.cost_open, Decimal::ZERO);
5559        assert_eq!(position.realized_pnl_remainder, Decimal::ZERO);
5560        assert_eq!(position.fill_voids.len(), 2);
5561    }
5562
5563    #[rstest]
5564    fn test_fill_void_replays_across_position_close_and_reopen(audusd_sim: CurrencyPair) {
5565        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
5566        let position_id = PositionId::from("P-VOID-REPLAY");
5567        let fill1 = OrderFilledSpec::builder()
5568            .instrument_id(instrument.id())
5569            .client_order_id(ClientOrderId::from("O-OPEN"))
5570            .trade_id(TradeId::from("T-OPEN"))
5571            .order_side(OrderSide::Buy)
5572            .last_qty(Quantity::from(10))
5573            .last_px(Price::from("1.00000"))
5574            .currency(Currency::USD())
5575            .position_id(position_id)
5576            .commission(Money::from("1.00 USD"))
5577            .ts_event(UnixNanos::from(1))
5578            .build();
5579        let fill2 = OrderFilledSpec::builder()
5580            .instrument_id(instrument.id())
5581            .client_order_id(ClientOrderId::from("O-CLOSE"))
5582            .trade_id(TradeId::from("T-CLOSE"))
5583            .order_side(OrderSide::Sell)
5584            .last_qty(Quantity::from(10))
5585            .last_px(Price::from("1.10000"))
5586            .currency(Currency::USD())
5587            .position_id(position_id)
5588            .commission(Money::from("1.00 USD"))
5589            .ts_event(UnixNanos::from(2))
5590            .build();
5591        let fill3 = OrderFilledSpec::builder()
5592            .instrument_id(instrument.id())
5593            .client_order_id(ClientOrderId::from("O-REOPEN"))
5594            .trade_id(TradeId::from("T-REOPEN"))
5595            .order_side(OrderSide::Buy)
5596            .last_qty(Quantity::from(5))
5597            .last_px(Price::from("1.20000"))
5598            .currency(Currency::USD())
5599            .position_id(position_id)
5600            .commission(Money::from("1.00 USD"))
5601            .ts_event(UnixNanos::from(3))
5602            .build();
5603        let fill_voided =
5604            matching_fill_void(&fill2, Quantity::from(5), Some(Money::from("0.50 USD")));
5605        let mut position = Position::new(&instrument, fill1);
5606        position.apply(&fill2);
5607        position.apply(&fill3);
5608
5609        position
5610            .apply_fill_void(
5611                fill_voided,
5612                Quantity::from(5),
5613                Some(Money::from("0.50 USD")),
5614            )
5615            .unwrap();
5616        let encoded = serde_json::to_string(&position).unwrap();
5617        let restored: Position = serde_json::from_str(&encoded).unwrap();
5618
5619        assert_eq!(position.side, PositionSide::Long);
5620        assert_eq!(position.quantity, Quantity::from(10));
5621        assert_eq!(position.opening_order_id, ClientOrderId::from("O-OPEN"));
5622        assert_eq!(position.buy_qty, Quantity::from(15));
5623        assert_eq!(position.sell_qty, Quantity::from(5));
5624        assert_eq!(position.commissions(), vec![Money::from("2.50 USD")]);
5625        assert_eq!(position.replay_events.len(), 3);
5626        assert_eq!(position.fill_voids.len(), 1);
5627        assert_eq!(restored.quantity, position.quantity);
5628        assert_eq!(restored.opening_order_id, position.opening_order_id);
5629        assert_eq!(restored.commissions(), position.commissions());
5630        assert_eq!(restored.replay_events.len(), position.replay_events.len());
5631        assert_eq!(restored.fill_voids.len(), position.fill_voids.len());
5632    }
5633
5634    #[rstest]
5635    fn test_fill_void_replays_manual_adjustment(audusd_sim: CurrencyPair) {
5636        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
5637        let position_id = PositionId::from("P-VOID-ADJUSTMENT");
5638        let fill = OrderFilledSpec::builder()
5639            .instrument_id(instrument.id())
5640            .client_order_id(ClientOrderId::from("O-VOID-ADJUSTMENT"))
5641            .trade_id(TradeId::from("T-VOID-ADJUSTMENT"))
5642            .order_side(OrderSide::Buy)
5643            .last_qty(Quantity::from(10))
5644            .last_px(Price::from("1.00000"))
5645            .currency(Currency::USD())
5646            .position_id(position_id)
5647            .ts_event(UnixNanos::from(1))
5648            .build();
5649        let fill_voided = matching_fill_void(&fill, Quantity::from(2), None);
5650        let adjustment = PositionAdjusted::new(
5651            fill.trader_id,
5652            fill.strategy_id,
5653            fill.instrument_id,
5654            position_id,
5655            fill.account_id,
5656            PositionAdjustmentType::Funding,
5657            None,
5658            Some(Money::from("5.00 USD")),
5659            Some("funding".into()),
5660            uuid4(),
5661            UnixNanos::from(2),
5662            UnixNanos::from(2),
5663        );
5664        let mut position = Position::new(&instrument, fill);
5665        position.apply_adjustment(adjustment).unwrap();
5666
5667        position
5668            .apply_fill_void(fill_voided, Quantity::from(2), None)
5669            .unwrap();
5670
5671        assert_eq!(position.side, PositionSide::Long);
5672        assert_eq!(position.quantity, Quantity::from(8));
5673        assert_eq!(position.realized_pnl, Some(Money::from("5.00 USD")));
5674        assert_eq!(position.adjustments, vec![adjustment]);
5675        assert_eq!(position.replay_events.len(), 2);
5676        assert_eq!(position.fill_voids.len(), 1);
5677        assert_eq!(position.ts_last, UnixNanos::from(2));
5678    }
5679
5680    fn binary_fill(
5681        instrument: &InstrumentAny,
5682        trade_id: &str,
5683        last_qty: &str,
5684        last_px: &str,
5685        ts_event: u64,
5686    ) -> OrderFilled {
5687        OrderFilledSpec::builder()
5688            .instrument_id(instrument.id())
5689            .client_order_id(ClientOrderId::from(format!("O-{trade_id}").as_str()))
5690            .venue_order_id(VenueOrderId::from(format!("V-{trade_id}").as_str()))
5691            .account_id(AccountId::from("POLYMARKET-001"))
5692            .trade_id(TradeId::from(trade_id))
5693            .order_side(OrderSide::Buy)
5694            .last_qty(Quantity::from(last_qty))
5695            .last_px(Price::from(last_px))
5696            .currency(Currency::USDC())
5697            .commission(Money::from("0.10 USDC"))
5698            .position_id(PositionId::from("P-BINARY"))
5699            .ts_event(UnixNanos::from(ts_event))
5700            .ts_init(UnixNanos::from(ts_event))
5701            .build()
5702    }
5703
5704    fn contract_expired(instrument: &InstrumentAny, close_price: &str) -> InstrumentClose {
5705        InstrumentClose::new(
5706            instrument.id(),
5707            Price::from(close_price),
5708            InstrumentCloseType::ContractExpired,
5709            UnixNanos::from(300),
5710            UnixNanos::from(301),
5711        )
5712    }
5713
5714    #[rstest]
5715    #[case::winner("1.000", dec!(5.90), 1.5)]
5716    #[case::loser("0.000", dec!(-4.10), -1.0)]
5717    fn test_apply_instrument_close_settles_without_fill(
5718        binary_option: BinaryOption,
5719        #[case] close_price: &str,
5720        #[case] expected_realized_pnl: Decimal,
5721        #[case] expected_return: f64,
5722    ) {
5723        let instrument = InstrumentAny::BinaryOption(binary_option);
5724        let fill = binary_fill(&instrument, "T-OPEN", "10.00", "0.400", 100);
5725        let mut position = Position::new(&instrument, fill.clone());
5726        let close = contract_expired(&instrument, close_price);
5727        let requires_replay_state_before = position.requires_replay_state();
5728
5729        position.apply_instrument_close(close).unwrap();
5730        let snapshot = PositionSnapshot::from_replay_state(&position, None);
5731        let restored: Position = serde_json::from_value(snapshot.replay_state.unwrap()).unwrap();
5732
5733        assert!(!requires_replay_state_before);
5734        assert!(position.requires_replay_state());
5735        assert!(position.is_closed());
5736        assert!(position.is_settled());
5737        assert_eq!(position.side, PositionSide::Flat);
5738        assert_eq!(position.signed_qty, dec!(0.0));
5739        assert_eq!(position.quantity, Quantity::from("0.00"));
5740        assert_eq!(position.peak_qty, Quantity::from("10.00"));
5741        assert_eq!(position.buy_qty, Quantity::from("10.00"));
5742        assert_eq!(position.sell_qty, Quantity::from("0.00"));
5743        assert_eq!(position.opening_order_id, fill.client_order_id);
5744        assert_eq!(position.closing_order_id, None);
5745        assert_eq!(position.events, vec![fill]);
5746        assert_eq!(position.commissions(), vec![Money::from("0.10 USDC")]);
5747        assert_eq!(position.avg_px_open, dec!(0.4));
5748        assert_eq!(
5749            position.avg_px_close,
5750            Some(Price::from(close_price).as_decimal())
5751        );
5752        assert!((position.realized_return - expected_return).abs() < 1e-12);
5753        assert_eq!(
5754            position.realized_pnl.unwrap().as_decimal(),
5755            expected_realized_pnl
5756        );
5757        assert_eq!(position.ts_last, UnixNanos::from(300));
5758        assert_eq!(position.ts_closed, Some(UnixNanos::from(300)));
5759        assert_eq!(position.duration_ns, DurationNanos::new(200));
5760        assert!(matches!(
5761            position.replay_events.last(),
5762            Some(PositionReplayEvent::InstrumentClosed(event)) if *event == close
5763        ));
5764        assert!(restored.is_settled());
5765        assert!(restored.is_closed());
5766        assert_eq!(restored.realized_pnl, position.realized_pnl);
5767        assert_eq!(restored.avg_px_close, position.avg_px_close);
5768        assert_eq!(restored.ts_closed, position.ts_closed);
5769    }
5770
5771    #[rstest]
5772    fn test_apply_instrument_close_after_partial_close(binary_option: BinaryOption) {
5773        let instrument = InstrumentAny::BinaryOption(binary_option);
5774        let opening_fill = binary_fill(&instrument, "T-OPEN", "10.00", "0.400", 100);
5775        let mut reducing_fill = binary_fill(&instrument, "T-REDUCE", "4.00", "0.600", 200);
5776        reducing_fill.order_side = OrderSide::Sell;
5777        let mut position = Position::new(&instrument, opening_fill);
5778        position.apply(&reducing_fill);
5779
5780        position
5781            .apply_instrument_close(contract_expired(&instrument, "1.000"))
5782            .unwrap();
5783
5784        assert!(position.is_closed());
5785        assert_eq!(position.quantity, Quantity::from("0.00"));
5786        assert_eq!(position.buy_qty, Quantity::from("10.00"));
5787        assert_eq!(position.sell_qty, Quantity::from("4.00"));
5788        assert!((position.avg_px_close.unwrap() - dec!(0.84)).abs() < dec!(1e-12));
5789        assert!((position.realized_return - 1.1).abs() < 1e-12);
5790        assert_eq!(position.realized_pnl.unwrap().as_decimal(), dec!(4.20));
5791        assert_eq!(position.closing_order_id, None);
5792    }
5793
5794    #[rstest]
5795    #[case::fills_only(false, false, false)]
5796    #[case::fill_voided(true, false, true)]
5797    #[case::settled(false, true, true)]
5798    fn test_requires_replay_state(
5799        binary_option: BinaryOption,
5800        #[case] void_fill: bool,
5801        #[case] settle: bool,
5802        #[case] expected: bool,
5803    ) {
5804        let instrument = InstrumentAny::BinaryOption(binary_option);
5805        let fill = binary_fill(&instrument, "T-OPEN", "10.00", "0.400", 100);
5806        let mut position = Position::new(&instrument, fill.clone());
5807
5808        if void_fill {
5809            position
5810                .apply_fill_void(
5811                    matching_fill_void(&fill, Quantity::from("2.00"), None),
5812                    Quantity::from("2.00"),
5813                    None,
5814                )
5815                .unwrap();
5816        }
5817
5818        if settle {
5819            position
5820                .apply_instrument_close(contract_expired(&instrument, "1.000"))
5821                .unwrap();
5822        }
5823
5824        assert_eq!(position.requires_replay_state(), expected);
5825    }
5826
5827    #[rstest]
5828    #[case::other_instrument(Some("OTHER.POLYMARKET"), InstrumentCloseType::ContractExpired, false)]
5829    #[case::end_of_session(None, InstrumentCloseType::EndOfSession, false)]
5830    #[case::not_open(None, InstrumentCloseType::ContractExpired, true)]
5831    fn test_apply_instrument_close_rejects_without_mutation(
5832        binary_option: BinaryOption,
5833        #[case] instrument_id: Option<&str>,
5834        #[case] close_type: InstrumentCloseType,
5835        #[case] settle_first: bool,
5836    ) {
5837        let instrument = InstrumentAny::BinaryOption(binary_option);
5838        let fill = binary_fill(&instrument, "T-OPEN", "10.00", "0.400", 100);
5839        let mut position = Position::new(&instrument, fill);
5840
5841        if settle_first {
5842            position
5843                .apply_instrument_close(contract_expired(&instrument, "1.000"))
5844                .unwrap();
5845        }
5846
5847        let before = serde_json::to_value(&position).unwrap();
5848
5849        let close = InstrumentClose::new(
5850            instrument_id.map_or_else(|| instrument.id(), InstrumentId::from),
5851            Price::from("1.000"),
5852            close_type,
5853            UnixNanos::from(400),
5854            UnixNanos::from(401),
5855        );
5856
5857        let result = position.apply_instrument_close(close);
5858
5859        assert!(result.is_err());
5860        assert_eq!(serde_json::to_value(&position).unwrap(), before);
5861    }
5862
5863    #[rstest]
5864    fn test_fill_void_replays_instrument_close(binary_option: BinaryOption) {
5865        let instrument = InstrumentAny::BinaryOption(binary_option);
5866        let opening_fill = binary_fill(&instrument, "T-OPEN", "10.00", "0.400", 100);
5867        let adding_fill = binary_fill(&instrument, "T-ADD", "5.00", "0.500", 200);
5868        let fill_voided = matching_fill_void(&adding_fill, Quantity::from("5.00"), None);
5869        let mut position = Position::new(&instrument, opening_fill);
5870        position.apply(&adding_fill);
5871        let close = contract_expired(&instrument, "1.000");
5872        position.apply_instrument_close(close).unwrap();
5873
5874        let closed_cycles_pnl = position
5875            .apply_fill_void(fill_voided, Quantity::from("5.00"), None)
5876            .unwrap();
5877
5878        assert_eq!(closed_cycles_pnl, None);
5879        assert!(position.is_closed());
5880        assert!(position.is_settled());
5881        assert_eq!(position.quantity, Quantity::from("0.00"));
5882        assert_eq!(position.peak_qty, Quantity::from("10.00"));
5883        assert_eq!(position.buy_qty, Quantity::from("10.00"));
5884        assert_eq!(position.realized_pnl.unwrap().as_decimal(), dec!(5.80));
5885        assert_eq!(position.ts_closed, Some(UnixNanos::from(300)));
5886        assert_eq!(position.fill_voids.len(), 1);
5887        assert_eq!(position.replay_events.len(), 3);
5888    }
5889
5890    #[rstest]
5891    fn test_fill_void_returns_all_closed_cycle_pnl(audusd_sim: CurrencyPair) {
5892        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
5893        let position_id = PositionId::from("P-VOID-CYCLES");
5894        let fill = |client_order_id: &str,
5895                    trade_id: &str,
5896                    order_side: OrderSide,
5897                    quantity: u32,
5898                    price: &str,
5899                    ts_event: u64| {
5900            OrderFilledSpec::builder()
5901                .instrument_id(instrument.id())
5902                .client_order_id(ClientOrderId::from(client_order_id))
5903                .trade_id(TradeId::from(trade_id))
5904                .order_side(order_side)
5905                .last_qty(Quantity::from(quantity))
5906                .last_px(Price::from(price))
5907                .currency(Currency::USD())
5908                .position_id(position_id)
5909                .ts_event(UnixNanos::from(ts_event))
5910                .build()
5911        };
5912        let fills = [
5913            fill("O-OPEN-1", "T-OPEN-1", OrderSide::Buy, 10, "1.0", 1),
5914            fill("O-CLOSE-1", "T-CLOSE-1", OrderSide::Sell, 10, "2.0", 2),
5915            fill("O-OPEN-2", "T-OPEN-2", OrderSide::Buy, 10, "3.0", 3),
5916            fill("O-CLOSE-2", "T-CLOSE-2", OrderSide::Sell, 10, "5.0", 4),
5917            fill("O-CURRENT", "T-CURRENT", OrderSide::Buy, 5, "6.0", 5),
5918        ];
5919        let current = fills.last().unwrap();
5920        let fill_voided = matching_fill_void(current, Quantity::from(1), None);
5921        let mut position = Position::new(&instrument, fills[0].clone());
5922        for fill in &fills[1..] {
5923            position.apply(fill);
5924        }
5925
5926        let closed_cycles_pnl = position
5927            .apply_fill_void(fill_voided, Quantity::from(1), None)
5928            .unwrap();
5929
5930        assert_eq!(closed_cycles_pnl, Some(Money::from("30.00 USD")));
5931        assert_eq!(position.side, PositionSide::Long);
5932        assert_eq!(position.quantity, Quantity::from(4));
5933        assert_eq!(position.avg_px_open, dec!(6.0));
5934        assert_eq!(position.realized_pnl, Some(Money::from("0.00 USD")));
5935        assert_eq!(position.events.len(), 1);
5936        assert_eq!(position.replay_events.len(), 5);
5937        assert_eq!(position.fill_voids.len(), 1);
5938    }
5939
5940    #[rstest]
5941    #[case::positive(MONEY_RAW_MAX, 1)]
5942    #[case::negative(-MONEY_RAW_MAX, -1)]
5943    fn test_bank_closed_cycle_pnl_rejects_overflow(
5944        #[case] total_raw: MoneyRaw,
5945        #[case] change_raw: MoneyRaw,
5946    ) {
5947        let total = Money::from_raw(total_raw, Currency::USD());
5948        let change = Money::from_raw(change_raw, Currency::USD());
5949
5950        let error = Position::bank_closed_cycle_pnl(Some(total), change).unwrap_err();
5951
5952        assert!(matches!(
5953            error,
5954            CorrectnessError::PredicateViolation { message }
5955                if message == "closed cycle PnL overflow"
5956        ));
5957    }
5958
5959    #[rstest]
5960    fn test_full_fill_void_preserves_unvoided_commission(audusd_sim: CurrencyPair) {
5961        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
5962        let position_id = PositionId::from("P-FEE-VOID");
5963        let fill = OrderFilledSpec::builder()
5964            .instrument_id(instrument.id())
5965            .client_order_id(ClientOrderId::from("O-FEE"))
5966            .trade_id(TradeId::from("T-FEE"))
5967            .order_side(OrderSide::Buy)
5968            .last_qty(Quantity::from(10))
5969            .last_px(Price::from("1.00000"))
5970            .currency(Currency::USD())
5971            .position_id(position_id)
5972            .commission(Money::from("1.00 USD"))
5973            .build();
5974        let fill_voided = OrderFillVoidedSpec::builder()
5975            .instrument_id(fill.instrument_id)
5976            .client_order_id(fill.client_order_id)
5977            .venue_order_id(fill.venue_order_id)
5978            .account_id(fill.account_id)
5979            .trade_id(fill.trade_id)
5980            .voided_qty(fill.last_qty)
5981            .order_side(fill.order_side)
5982            .order_type(fill.order_type)
5983            .last_px(fill.last_px)
5984            .currency(fill.currency)
5985            .liquidity_side(fill.liquidity_side)
5986            .build();
5987        let mut position = Position::new(&instrument, fill);
5988
5989        position
5990            .apply_fill_void(fill_voided, Quantity::from(10), None)
5991            .unwrap();
5992
5993        assert_eq!(position.side, PositionSide::Flat);
5994        assert_eq!(position.quantity, Quantity::from(0));
5995        assert_eq!(position.commissions(), vec![Money::from("1.00 USD")]);
5996        assert_eq!(position.realized_pnl, Some(Money::from("-1.00 USD")));
5997        assert!(position.events.is_empty());
5998    }
5999
6000    #[rstest]
6001    fn test_full_fill_void_preserves_unvoided_base_commission() {
6002        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
6003        let position_id = PositionId::from("P-BASE-FEE-VOID");
6004        let fill = OrderFilledSpec::builder()
6005            .instrument_id(instrument.id())
6006            .client_order_id(ClientOrderId::from("O-BASE-FEE"))
6007            .trade_id(TradeId::from("T-BASE-FEE"))
6008            .order_side(OrderSide::Buy)
6009            .last_qty(Quantity::from("1.000000"))
6010            .last_px(Price::from("50000.00"))
6011            .currency(Currency::USDT())
6012            .position_id(position_id)
6013            .commission(Money::from("0.00100000 BTC"))
6014            .ts_event(UnixNanos::from(2_000))
6015            .ts_init(UnixNanos::from(1_900))
6016            .build();
6017        let fill_voided = matching_fill_void(&fill, fill.last_qty, None);
6018        let mut position = Position::new(&instrument, fill);
6019
6020        let closed_cycles_pnl = position
6021            .apply_fill_void(fill_voided, Quantity::from("1.000000"), None)
6022            .unwrap();
6023
6024        assert_eq!(closed_cycles_pnl, None);
6025        assert_eq!(position.entry, OrderSide::Sell);
6026        assert_eq!(position.side, PositionSide::Short);
6027        assert_eq!(position.signed_decimal_qty(), dec!(-0.001));
6028        assert_eq!(position.quantity.as_decimal(), dec!(0.001));
6029        assert_eq!(position.buy_qty.as_decimal(), Decimal::ZERO);
6030        assert_eq!(position.sell_qty.as_decimal(), Decimal::ZERO);
6031        assert_eq!(position.commissions(), vec![Money::from("0.00100000 BTC")]);
6032        assert_eq!(position.adjustments.len(), 1);
6033        assert_eq!(
6034            position.adjustments[0].adjustment_type,
6035            PositionAdjustmentType::Commission
6036        );
6037        assert_eq!(position.adjustments[0].quantity_change, Some(dec!(-0.001)));
6038        assert_eq!(position.opening_order_id, ClientOrderId::from("O-BASE-FEE"));
6039        assert_eq!(position.closing_order_id, None);
6040        assert_eq!(position.ts_init, UnixNanos::from(1_900));
6041        assert_eq!(position.ts_opened, UnixNanos::from(2_000));
6042        assert_eq!(position.ts_last, UnixNanos::from(2_000));
6043        assert_eq!(position.ts_closed, None);
6044        assert_eq!(position.duration_ns, DurationNanos::default());
6045        assert_eq!(position.avg_px_open, dec!(50_000.0));
6046        assert_eq!(position.avg_px_close, None);
6047        assert_eq!(position.realized_pnl, None);
6048        assert!(position.events.is_empty());
6049        assert!(position.is_open());
6050        assert!(!position.is_closed());
6051    }
6052
6053    #[rstest]
6054    fn test_surviving_base_commission_can_close_position() {
6055        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
6056        let position_id = PositionId::from("P-BASE-FEE-CLOSE");
6057        let opening = OrderFilledSpec::builder()
6058            .instrument_id(instrument.id())
6059            .client_order_id(ClientOrderId::from("O-BASE-OPEN"))
6060            .trade_id(TradeId::from("T-BASE-OPEN"))
6061            .order_side(OrderSide::Buy)
6062            .last_qty(Quantity::from("0.001000"))
6063            .last_px(Price::from("50000.00"))
6064            .currency(Currency::USDT())
6065            .position_id(position_id)
6066            .ts_event(UnixNanos::from(1_000))
6067            .ts_init(UnixNanos::from(900))
6068            .build();
6069        let fee_fill = OrderFilledSpec::builder()
6070            .instrument_id(instrument.id())
6071            .client_order_id(ClientOrderId::from("O-BASE-FEE"))
6072            .trade_id(TradeId::from("T-BASE-FEE"))
6073            .order_side(OrderSide::Buy)
6074            .last_qty(Quantity::from("1.000000"))
6075            .last_px(Price::from("51000.00"))
6076            .currency(Currency::USDT())
6077            .position_id(position_id)
6078            .commission(Money::from("0.00100000 BTC"))
6079            .ts_event(UnixNanos::from(2_000))
6080            .ts_init(UnixNanos::from(1_900))
6081            .build();
6082        let fill_voided = matching_fill_void(&fee_fill, fee_fill.last_qty, None);
6083        let mut position = Position::new(&instrument, opening);
6084        position.apply(&fee_fill);
6085
6086        let closed_cycles_pnl = position
6087            .apply_fill_void(fill_voided, Quantity::from("1.000000"), None)
6088            .unwrap();
6089
6090        assert_eq!(closed_cycles_pnl, None);
6091        assert_eq!(position.entry, OrderSide::Buy);
6092        assert_eq!(position.side, PositionSide::Flat);
6093        assert_eq!(position.signed_decimal_qty(), Decimal::ZERO);
6094        assert_eq!(position.quantity.as_decimal(), Decimal::ZERO);
6095        assert_eq!(position.buy_qty.as_decimal(), dec!(0.001));
6096        assert_eq!(position.sell_qty.as_decimal(), Decimal::ZERO);
6097        assert_eq!(position.commissions(), vec![Money::from("0.00100000 BTC")]);
6098        assert_eq!(position.events.len(), 1);
6099        assert_eq!(position.adjustments.len(), 1);
6100        assert_eq!(
6101            position.opening_order_id,
6102            ClientOrderId::from("O-BASE-OPEN")
6103        );
6104        assert_eq!(
6105            position.closing_order_id,
6106            Some(ClientOrderId::from("O-BASE-FEE"))
6107        );
6108        assert_eq!(position.ts_init, UnixNanos::from(900));
6109        assert_eq!(position.ts_opened, UnixNanos::from(1_000));
6110        assert_eq!(position.ts_last, UnixNanos::from(2_000));
6111        assert_eq!(position.ts_closed, Some(UnixNanos::from(2_000)));
6112        assert_eq!(position.duration_ns, DurationNanos::new(1_000));
6113        assert_eq!(position.avg_px_open, dec!(50_000.0));
6114        assert_eq!(position.avg_px_close, None);
6115        assert_eq!(position.realized_pnl, Some(Money::from("0.00 USDT")));
6116        assert!(!position.is_open());
6117        assert!(position.is_closed());
6118    }
6119
6120    #[rstest]
6121    fn test_surviving_base_commission_reopen_returns_previous_cycle_pnl() {
6122        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
6123        let position_id = PositionId::from("P-BASE-FEE-REOPEN");
6124        let opening = OrderFilledSpec::builder()
6125            .instrument_id(instrument.id())
6126            .client_order_id(ClientOrderId::from("O-OPEN"))
6127            .trade_id(TradeId::from("T-OPEN"))
6128            .order_side(OrderSide::Buy)
6129            .last_qty(Quantity::from("1.000000"))
6130            .last_px(Price::from("50000.00"))
6131            .currency(Currency::USDT())
6132            .position_id(position_id)
6133            .ts_event(UnixNanos::from(1_000))
6134            .build();
6135        let closing = OrderFilledSpec::builder()
6136            .instrument_id(instrument.id())
6137            .client_order_id(ClientOrderId::from("O-CLOSE"))
6138            .trade_id(TradeId::from("T-CLOSE"))
6139            .order_side(OrderSide::Sell)
6140            .last_qty(Quantity::from("1.000000"))
6141            .last_px(Price::from("51000.00"))
6142            .currency(Currency::USDT())
6143            .position_id(position_id)
6144            .ts_event(UnixNanos::from(2_000))
6145            .build();
6146        let reopening = OrderFilledSpec::builder()
6147            .instrument_id(instrument.id())
6148            .client_order_id(ClientOrderId::from("O-REOPEN"))
6149            .trade_id(TradeId::from("T-REOPEN"))
6150            .order_side(OrderSide::Buy)
6151            .last_qty(Quantity::from("1.000000"))
6152            .last_px(Price::from("52000.00"))
6153            .currency(Currency::USDT())
6154            .position_id(position_id)
6155            .commission(Money::from("0.00100000 BTC"))
6156            .ts_event(UnixNanos::from(3_000))
6157            .ts_init(UnixNanos::from(2_900))
6158            .build();
6159        let fill_voided = matching_fill_void(&reopening, reopening.last_qty, None);
6160        let mut position = Position::new(&instrument, opening);
6161        position.apply(&closing);
6162        position.apply(&reopening);
6163
6164        let closed_cycles_pnl = position
6165            .apply_fill_void(fill_voided, Quantity::from("1.000000"), None)
6166            .unwrap();
6167
6168        assert_eq!(closed_cycles_pnl, Some(Money::from("1000.00 USDT")));
6169        assert_eq!(position.entry, OrderSide::Sell);
6170        assert_eq!(position.side, PositionSide::Short);
6171        assert_eq!(position.signed_decimal_qty(), dec!(-0.001));
6172        assert_eq!(position.quantity.as_decimal(), dec!(0.001));
6173        assert_eq!(position.buy_qty.as_decimal(), Decimal::ZERO);
6174        assert_eq!(position.sell_qty.as_decimal(), Decimal::ZERO);
6175        assert_eq!(position.commissions(), vec![Money::from("0.00100000 BTC")]);
6176        assert!(position.events.is_empty());
6177        assert_eq!(position.adjustments.len(), 1);
6178        assert_eq!(position.opening_order_id, ClientOrderId::from("O-REOPEN"));
6179        assert_eq!(position.closing_order_id, None);
6180        assert_eq!(position.ts_init, UnixNanos::from(2_900));
6181        assert_eq!(position.ts_opened, UnixNanos::from(3_000));
6182        assert_eq!(position.ts_last, UnixNanos::from(3_000));
6183        assert_eq!(position.ts_closed, None);
6184        assert_eq!(position.duration_ns, DurationNanos::default());
6185        assert_eq!(position.avg_px_open, dec!(52_000.0));
6186        assert_eq!(position.avg_px_close, None);
6187        assert_eq!(position.realized_pnl, None);
6188        assert!(position.is_open());
6189        assert!(!position.is_closed());
6190    }
6191
6192    #[rstest]
6193    fn test_surviving_base_commission_can_flip_position() {
6194        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
6195        let position_id = PositionId::from("P-BASE-FEE-FLIP");
6196        let opening = OrderFilledSpec::builder()
6197            .instrument_id(instrument.id())
6198            .client_order_id(ClientOrderId::from("O-BASE-OPEN"))
6199            .trade_id(TradeId::from("T-BASE-OPEN"))
6200            .order_side(OrderSide::Buy)
6201            .last_qty(Quantity::from("0.000500"))
6202            .last_px(Price::from("50000.00"))
6203            .currency(Currency::USDT())
6204            .position_id(position_id)
6205            .ts_event(UnixNanos::from(1_000))
6206            .ts_init(UnixNanos::from(900))
6207            .build();
6208        let fee_fill = OrderFilledSpec::builder()
6209            .instrument_id(instrument.id())
6210            .client_order_id(ClientOrderId::from("O-BASE-FEE"))
6211            .trade_id(TradeId::from("T-BASE-FEE"))
6212            .order_side(OrderSide::Buy)
6213            .last_qty(Quantity::from("1.000000"))
6214            .last_px(Price::from("52000.00"))
6215            .currency(Currency::USDT())
6216            .position_id(position_id)
6217            .commission(Money::from("0.00100000 BTC"))
6218            .ts_event(UnixNanos::from(2_000))
6219            .ts_init(UnixNanos::from(1_900))
6220            .build();
6221        let fill_voided = matching_fill_void(&fee_fill, fee_fill.last_qty, None);
6222        let mut position = Position::new(&instrument, opening);
6223        position.apply(&fee_fill);
6224
6225        let closed_cycles_pnl = position
6226            .apply_fill_void(fill_voided, Quantity::from("1.000000"), None)
6227            .unwrap();
6228
6229        assert_eq!(closed_cycles_pnl, None);
6230        assert_eq!(position.entry, OrderSide::Sell);
6231        assert_eq!(position.side, PositionSide::Short);
6232        assert_eq!(position.signed_decimal_qty(), dec!(-0.0005));
6233        assert_eq!(position.quantity.as_decimal(), dec!(0.0005));
6234        assert_eq!(position.buy_qty.as_decimal(), dec!(0.0005));
6235        assert_eq!(position.sell_qty.as_decimal(), Decimal::ZERO);
6236        assert_eq!(position.commissions(), vec![Money::from("0.00100000 BTC")]);
6237        assert_eq!(position.events.len(), 1);
6238        assert_eq!(position.adjustments.len(), 1);
6239        assert_eq!(
6240            position.opening_order_id,
6241            ClientOrderId::from("O-BASE-OPEN")
6242        );
6243        assert_eq!(position.closing_order_id, None);
6244        assert_eq!(position.ts_init, UnixNanos::from(900));
6245        assert_eq!(position.ts_opened, UnixNanos::from(1_000));
6246        assert_eq!(position.ts_last, UnixNanos::from(2_000));
6247        assert_eq!(position.ts_closed, None);
6248        assert_eq!(position.duration_ns, DurationNanos::default());
6249        assert_eq!(position.avg_px_open, dec!(52_000.0));
6250        assert_eq!(position.avg_px_close, None);
6251        assert_eq!(position.realized_pnl, Some(Money::from("0.00 USDT")));
6252        assert!(position.is_open());
6253        assert!(!position.is_closed());
6254    }
6255
6256    #[rstest]
6257    fn test_fill_void_replays_netting_flip_fragments_with_one_trade_id(audusd_sim: CurrencyPair) {
6258        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
6259        let position_id = PositionId::from("P-FLIP-VOID");
6260        let opening = OrderFilledSpec::builder()
6261            .instrument_id(instrument.id())
6262            .client_order_id(ClientOrderId::from("O-OPEN"))
6263            .trade_id(TradeId::from("T-OPEN"))
6264            .order_side(OrderSide::Buy)
6265            .last_qty(Quantity::from(10))
6266            .last_px(Price::from("1.00000"))
6267            .currency(Currency::USD())
6268            .position_id(position_id)
6269            .build();
6270        let closing = OrderFilledSpec::builder()
6271            .instrument_id(instrument.id())
6272            .client_order_id(ClientOrderId::from("O-FLIP"))
6273            .trade_id(TradeId::from("T-FLIP"))
6274            .order_side(OrderSide::Sell)
6275            .last_qty(Quantity::from(10))
6276            .last_px(Price::from("1.10000"))
6277            .currency(Currency::USD())
6278            .position_id(position_id)
6279            .build();
6280        let mut reopening = closing.clone();
6281        reopening.last_qty = Quantity::from(5);
6282        reopening.event_id = uuid4();
6283        reopening.causation_id = Some(closing.event_id);
6284        let fill_voided = matching_fill_void(&closing, Quantity::from(12), None);
6285        let mut position = Position::new(&instrument, opening);
6286        position.apply(&closing);
6287        assert!(!position.is_duplicate_replay_fill(&reopening));
6288        position.apply(&reopening);
6289
6290        position
6291            .apply_fill_void(fill_voided, Quantity::from(12), None)
6292            .unwrap();
6293
6294        assert_eq!(position.side, PositionSide::Long);
6295        assert_eq!(position.quantity, Quantity::from(7));
6296        assert_eq!(position.buy_qty, Quantity::from(10));
6297        assert_eq!(position.sell_qty, Quantity::from(3));
6298        assert_eq!(position.replay_events.len(), 3);
6299        assert!(position.is_duplicate_replay_fill(&reopening));
6300    }
6301
6302    #[rstest]
6303    fn test_fill_void_replays_split_fragments_in_one_corrected_cycle(audusd_sim: CurrencyPair) {
6304        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
6305        let position_id = PositionId::from("P-FLIP-CYCLE-VOID");
6306        let opening = OrderFilledSpec::builder()
6307            .instrument_id(instrument.id())
6308            .client_order_id(ClientOrderId::from("O-SELL-1"))
6309            .trade_id(TradeId::from("T-SELL-1"))
6310            .order_side(OrderSide::Sell)
6311            .last_qty(Quantity::from(17))
6312            .last_px(Price::from("1.00000"))
6313            .currency(Currency::USD())
6314            .position_id(position_id)
6315            .build();
6316        let second_sell = OrderFilledSpec::builder()
6317            .instrument_id(instrument.id())
6318            .client_order_id(ClientOrderId::from("O-SELL-2"))
6319            .trade_id(TradeId::from("T-SELL-2"))
6320            .order_side(OrderSide::Sell)
6321            .last_qty(Quantity::from(17))
6322            .last_px(Price::from("1.00000"))
6323            .currency(Currency::USD())
6324            .position_id(position_id)
6325            .build();
6326        let closing = OrderFilledSpec::builder()
6327            .instrument_id(instrument.id())
6328            .client_order_id(ClientOrderId::from("O-FLIP"))
6329            .trade_id(TradeId::from("T-FLIP"))
6330            .order_side(OrderSide::Buy)
6331            .last_qty(Quantity::from(34))
6332            .last_px(Price::from("1.10000"))
6333            .currency(Currency::USD())
6334            .position_id(position_id)
6335            .build();
6336        let mut reopening = closing.clone();
6337        reopening.last_qty = Quantity::from(591);
6338        reopening.event_id = uuid4();
6339        reopening.causation_id = Some(closing.event_id);
6340        let fill_voided = matching_fill_void(&second_sell, Quantity::from(2), None);
6341        let mut position = Position::new(&instrument, opening);
6342        position.apply(&second_sell);
6343        position.apply(&closing);
6344        position.apply(&reopening);
6345
6346        position
6347            .apply_fill_void(fill_voided, Quantity::from(2), None)
6348            .unwrap();
6349
6350        assert_eq!(position.side, PositionSide::Long);
6351        assert_eq!(position.quantity, Quantity::from(593));
6352        // The reversal starts a new episode with only the opening residual
6353        assert_eq!(position.buy_qty, Quantity::from(593));
6354        assert_eq!(position.sell_qty, Quantity::from(0));
6355        assert_eq!(position.events.len(), 4);
6356        assert_eq!(position.replay_events.len(), 4);
6357        assert_eq!(position.fill_voids.len(), 1);
6358        assert_eq!(position.trade_ids.len(), 3);
6359        assert!(position.trade_ids.contains(&TradeId::from("T-FLIP")));
6360    }
6361
6362    #[rstest]
6363    fn test_fill_void_replays_partially_voided_reversal(audusd_sim: CurrencyPair) {
6364        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
6365        let position_id = PositionId::from("P-REVERSAL-PARTIAL-VOID");
6366        let opening = OrderFilledSpec::builder()
6367            .instrument_id(instrument.id())
6368            .client_order_id(ClientOrderId::from("O-OPEN"))
6369            .trade_id(TradeId::from("T-OPEN"))
6370            .order_side(OrderSide::Sell)
6371            .last_qty(Quantity::from(10))
6372            .last_px(Price::from("1.00000"))
6373            .currency(Currency::USD())
6374            .position_id(position_id)
6375            .build();
6376        let partial_close = OrderFilledSpec::builder()
6377            .instrument_id(instrument.id())
6378            .client_order_id(ClientOrderId::from("O-CLOSE"))
6379            .trade_id(TradeId::from("T-CLOSE"))
6380            .order_side(OrderSide::Buy)
6381            .last_qty(Quantity::from(4))
6382            .last_px(Price::from("0.90000"))
6383            .currency(Currency::USD())
6384            .position_id(position_id)
6385            .build();
6386        let reversal = OrderFilledSpec::builder()
6387            .instrument_id(instrument.id())
6388            .client_order_id(ClientOrderId::from("O-REVERSE"))
6389            .trade_id(TradeId::from("T-REVERSE"))
6390            .order_side(OrderSide::Buy)
6391            .last_qty(Quantity::from(11))
6392            .last_px(Price::from("1.10000"))
6393            .currency(Currency::USD())
6394            .position_id(position_id)
6395            .build();
6396        let fill_voided = matching_fill_void(&reversal, Quantity::from(2), None);
6397        let mut position = Position::new(&instrument, opening);
6398        position.apply(&partial_close);
6399        position.apply(&reversal);
6400
6401        position
6402            .apply_fill_void(fill_voided, Quantity::from(2), None)
6403            .unwrap();
6404
6405        assert_eq!(position.side, PositionSide::Long);
6406        assert_eq!(position.quantity, Quantity::from(3));
6407        assert_eq!(position.avg_px_open, dec!(1.1));
6408        assert_eq!(position.avg_px_close, None);
6409        assert_eq!(position.realized_return, 0.0);
6410        assert_eq!(position.buy_qty, Quantity::from(3));
6411        assert_eq!(position.sell_qty, Quantity::from(0));
6412        assert_eq!(position.realized_pnl, Some(Money::from("-0.20 USD")));
6413        assert_eq!(position.fill_voids.len(), 1);
6414    }
6415
6416    #[rstest]
6417    fn test_position_realized_pnl_with_interleaved_order_sides(
6418        currency_pair_btcusdt: CurrencyPair,
6419    ) {
6420        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
6421        let order1 = OrderTestBuilder::new(OrderType::Market)
6422            .instrument_id(btcusdt.id())
6423            .side(OrderSide::Buy)
6424            .quantity(Quantity::from(12))
6425            .build();
6426        let commission1 = calculate_commission(
6427            &btcusdt,
6428            order1.quantity(),
6429            Price::from("10000.0"),
6430            None,
6431            dec!(0.001),
6432        );
6433        let fill1 = TestOrderEventStubs::filled(
6434            &order1,
6435            &btcusdt,
6436            Some(TradeId::from("1")),
6437            Some(PositionId::from("P-19700101-000000-001-001-1")),
6438            Some(Price::from("10000.0")),
6439            None,
6440            None,
6441            Some(commission1),
6442            None,
6443            None,
6444        );
6445        let mut position = Position::new(&btcusdt, fill1.into());
6446        let order2 = OrderTestBuilder::new(OrderType::Market)
6447            .instrument_id(btcusdt.id())
6448            .side(OrderSide::Buy)
6449            .quantity(Quantity::from(17))
6450            .build();
6451        let commission2 = calculate_commission(
6452            &btcusdt,
6453            order2.quantity(),
6454            Price::from("9999.0"),
6455            None,
6456            dec!(0.001),
6457        );
6458        let fill2 = TestOrderEventStubs::filled(
6459            &order2,
6460            &btcusdt,
6461            Some(TradeId::from("2")),
6462            Some(PositionId::from("P-19700101-000000-001-001-1")),
6463            Some(Price::from("9999.0")),
6464            None,
6465            None,
6466            Some(commission2),
6467            None,
6468            None,
6469        );
6470        position.apply(&fill2.into());
6471        assert_eq!(position.quantity, Quantity::from(29));
6472        assert_eq!(
6473            position.realized_pnl,
6474            Some(Money::from("-289.98300000 USDT"))
6475        );
6476        assert_eq!(position.avg_px_open, (dec!(289983) / dec!(29)));
6477        let order3 = OrderTestBuilder::new(OrderType::Market)
6478            .instrument_id(btcusdt.id())
6479            .side(OrderSide::Sell)
6480            .quantity(Quantity::from(9))
6481            .build();
6482        let commission3 = calculate_commission(
6483            &btcusdt,
6484            order3.quantity(),
6485            Price::from("10001.0"),
6486            None,
6487            dec!(0.001),
6488        );
6489        let fill3 = TestOrderEventStubs::filled(
6490            &order3,
6491            &btcusdt,
6492            Some(TradeId::from("3")),
6493            Some(PositionId::from("P-19700101-000000-001-001-1")),
6494            Some(Price::from("10001.0")),
6495            None,
6496            None,
6497            Some(commission3),
6498            None,
6499            None,
6500        );
6501        position.apply(&fill3.into());
6502        assert_eq!(position.quantity, Quantity::from(20));
6503        assert_eq!(
6504            position.realized_pnl,
6505            Some(native_money(dec!(-1325721) / dec!(3625), Currency::USDT()))
6506        );
6507        assert_eq!(position.avg_px_open, (dec!(289983) / dec!(29)));
6508        let order4 = OrderTestBuilder::new(OrderType::Market)
6509            .instrument_id(btcusdt.id())
6510            .side(OrderSide::Buy)
6511            .quantity(Quantity::from(3))
6512            .build();
6513        let commission4 = calculate_commission(
6514            &btcusdt,
6515            order4.quantity(),
6516            Price::from("10003.0"),
6517            None,
6518            dec!(0.001),
6519        );
6520        let fill4 = TestOrderEventStubs::filled(
6521            &order4,
6522            &btcusdt,
6523            Some(TradeId::from("4")),
6524            Some(PositionId::from("P-19700101-000000-001-001-1")),
6525            Some(Price::from("10003.0")),
6526            None,
6527            None,
6528            Some(commission4),
6529            None,
6530            None,
6531        );
6532        position.apply(&fill4.into());
6533        assert_eq!(position.quantity, Quantity::from(23));
6534        assert_eq!(
6535            position.realized_pnl,
6536            Some(native_money(
6537                dec!(-11476029) / dec!(29000),
6538                Currency::USDT()
6539            ))
6540        );
6541        assert_eq!(position.avg_px_open, (dec!(6669921) / dec!(667)));
6542        let order5 = OrderTestBuilder::new(OrderType::Market)
6543            .instrument_id(btcusdt.id())
6544            .side(OrderSide::Sell)
6545            .quantity(Quantity::from(4))
6546            .build();
6547        let commission5 = calculate_commission(
6548            &btcusdt,
6549            order5.quantity(),
6550            Price::from("10005.0"),
6551            None,
6552            dec!(0.001),
6553        );
6554        let fill5 = TestOrderEventStubs::filled(
6555            &order5,
6556            &btcusdt,
6557            Some(TradeId::from("5")),
6558            Some(PositionId::from("P-19700101-000000-001-001-1")),
6559            Some(Price::from("10005.0")),
6560            None,
6561            None,
6562            Some(commission5),
6563            None,
6564            None,
6565        );
6566        position.apply(&fill5.into());
6567        assert_eq!(position.quantity, Quantity::from(19));
6568        assert_eq!(
6569            position.realized_pnl,
6570            Some(native_money(
6571                dec!(-276986007) / dec!(667000),
6572                Currency::USDT()
6573            ))
6574        );
6575        assert_eq!(position.avg_px_open, (dec!(6669921) / dec!(667)));
6576        assert_eq!(
6577            format!("{position}"),
6578            "Position(LONG 19.000000 BTCUSDT.BINANCE, id=P-19700101-000000-001-001-1)"
6579        );
6580    }
6581
6582    #[rstest]
6583    fn test_calculate_pnl_when_given_position_side_flat_returns_zero(
6584        currency_pair_btcusdt: CurrencyPair,
6585    ) {
6586        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
6587        let order = OrderTestBuilder::new(OrderType::Market)
6588            .instrument_id(btcusdt.id())
6589            .side(OrderSide::Buy)
6590            .quantity(Quantity::from(12))
6591            .build();
6592        let fill = TestOrderEventStubs::filled(
6593            &order,
6594            &btcusdt,
6595            None,
6596            Some(PositionId::from("P-123456")),
6597            Some(Price::from("10500.0")),
6598            None,
6599            None,
6600            None,
6601            None,
6602            None,
6603        );
6604        let position = Position::new(&btcusdt, fill.into());
6605        let result = position
6606            .calculate_pnl(dec!(10500.0), dec!(10500.0), Quantity::from("100000.0"))
6607            .unwrap();
6608        assert_eq!(result, Money::from("0 USDT"));
6609    }
6610
6611    #[rstest]
6612    fn test_calculate_pnl_for_long_position_win(currency_pair_btcusdt: CurrencyPair) {
6613        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
6614        let order = OrderTestBuilder::new(OrderType::Market)
6615            .instrument_id(btcusdt.id())
6616            .side(OrderSide::Buy)
6617            .quantity(Quantity::from(12))
6618            .build();
6619        let commission = calculate_commission(
6620            &btcusdt,
6621            order.quantity(),
6622            Price::from("10500.0"),
6623            None,
6624            dec!(0.001),
6625        );
6626        let fill = TestOrderEventStubs::filled(
6627            &order,
6628            &btcusdt,
6629            None,
6630            Some(PositionId::from("P-123456")),
6631            Some(Price::from("10500.0")),
6632            None,
6633            None,
6634            Some(commission),
6635            None,
6636            None,
6637        );
6638        let position = Position::new(&btcusdt, fill.into());
6639        let pnl = position
6640            .calculate_pnl(dec!(10500.0), dec!(10510.0), Quantity::from("12.0"))
6641            .unwrap();
6642        assert_eq!(pnl, Money::from("120 USDT"));
6643        assert_eq!(position.realized_pnl, Some(Money::from("-126 USDT")));
6644        assert_eq!(
6645            position.unrealized_pnl(Price::from("10510.0")).unwrap(),
6646            Money::from("120.0 USDT")
6647        );
6648        assert_eq!(
6649            position.total_pnl(Price::from("10510.0")).unwrap(),
6650            Money::from("-6 USDT")
6651        );
6652        assert_eq!(position.commissions(), vec![Money::from("126.0 USDT")]);
6653    }
6654
6655    #[rstest]
6656    fn test_calculate_pnl_for_long_position_loss(currency_pair_btcusdt: CurrencyPair) {
6657        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
6658        let order = OrderTestBuilder::new(OrderType::Market)
6659            .instrument_id(btcusdt.id())
6660            .side(OrderSide::Buy)
6661            .quantity(Quantity::from(12))
6662            .build();
6663        let commission = calculate_commission(
6664            &btcusdt,
6665            order.quantity(),
6666            Price::from("10500.0"),
6667            None,
6668            dec!(0.001),
6669        );
6670        let fill = TestOrderEventStubs::filled(
6671            &order,
6672            &btcusdt,
6673            None,
6674            Some(PositionId::from("P-123456")),
6675            Some(Price::from("10500.0")),
6676            None,
6677            None,
6678            Some(commission),
6679            None,
6680            None,
6681        );
6682        let position = Position::new(&btcusdt, fill.into());
6683        let pnl = position
6684            .calculate_pnl(dec!(10500.0), dec!(10480.5), Quantity::from("10.0"))
6685            .unwrap();
6686        assert_eq!(pnl, Money::from("-195 USDT"));
6687        assert_eq!(position.realized_pnl, Some(Money::from("-126 USDT")));
6688        assert_eq!(
6689            position.unrealized_pnl(Price::from("10480.50")).unwrap(),
6690            Money::from("-234.0 USDT")
6691        );
6692        assert_eq!(
6693            position.total_pnl(Price::from("10480.50")).unwrap(),
6694            Money::from("-360 USDT")
6695        );
6696        assert_eq!(position.commissions(), vec![Money::from("126.0 USDT")]);
6697    }
6698
6699    #[rstest]
6700    fn test_calculate_pnl_for_short_position_winning(currency_pair_btcusdt: CurrencyPair) {
6701        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
6702        let order = OrderTestBuilder::new(OrderType::Market)
6703            .instrument_id(btcusdt.id())
6704            .side(OrderSide::Sell)
6705            .quantity(Quantity::from("10.15"))
6706            .build();
6707        let commission = calculate_commission(
6708            &btcusdt,
6709            order.quantity(),
6710            Price::from("10500.0"),
6711            None,
6712            dec!(0.001),
6713        );
6714        let fill = TestOrderEventStubs::filled(
6715            &order,
6716            &btcusdt,
6717            None,
6718            Some(PositionId::from("P-123456")),
6719            Some(Price::from("10500.0")),
6720            None,
6721            None,
6722            Some(commission),
6723            None,
6724            None,
6725        );
6726        let position = Position::new(&btcusdt, fill.into());
6727        let pnl = position
6728            .calculate_pnl(dec!(10500.0), dec!(10390.0), Quantity::from("10.15"))
6729            .unwrap();
6730        assert_eq!(pnl, Money::from("1116.5 USDT"));
6731        assert_eq!(
6732            position.unrealized_pnl(Price::from("10390.0")).unwrap(),
6733            Money::from("1116.5 USDT")
6734        );
6735        assert_eq!(position.realized_pnl, Some(Money::from("-106.575 USDT")));
6736        assert_eq!(position.commissions(), vec![Money::from("106.575 USDT")]);
6737        assert_eq!(
6738            position.notional_value(Price::from("10390.0")),
6739            Money::from("105458.5 USDT")
6740        );
6741    }
6742
6743    #[rstest]
6744    fn test_calculate_pnl_for_short_position_loss(currency_pair_btcusdt: CurrencyPair) {
6745        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
6746        let order = OrderTestBuilder::new(OrderType::Market)
6747            .instrument_id(btcusdt.id())
6748            .side(OrderSide::Sell)
6749            .quantity(Quantity::from("10.0"))
6750            .build();
6751        let commission = calculate_commission(
6752            &btcusdt,
6753            order.quantity(),
6754            Price::from("10500.0"),
6755            None,
6756            dec!(0.001),
6757        );
6758        let fill = TestOrderEventStubs::filled(
6759            &order,
6760            &btcusdt,
6761            None,
6762            Some(PositionId::from("P-123456")),
6763            Some(Price::from("10500.0")),
6764            None,
6765            None,
6766            Some(commission),
6767            None,
6768            None,
6769        );
6770        let position = Position::new(&btcusdt, fill.into());
6771        let pnl = position
6772            .calculate_pnl(dec!(10500.0), dec!(10670.5), Quantity::from("10.0"))
6773            .unwrap();
6774        assert_eq!(pnl, Money::from("-1705 USDT"));
6775        assert_eq!(
6776            position.unrealized_pnl(Price::from("10670.5")).unwrap(),
6777            Money::from("-1705 USDT")
6778        );
6779        assert_eq!(position.realized_pnl, Some(Money::from("-105 USDT")));
6780        assert_eq!(position.commissions(), vec![Money::from("105 USDT")]);
6781        assert_eq!(
6782            position.notional_value(Price::from("10670.5")),
6783            Money::from("106705 USDT")
6784        );
6785    }
6786
6787    #[rstest]
6788    fn test_calculate_pnl_for_inverse1(btcusd_bybit: CryptoPerpetual) {
6789        let btcusd_bybit = InstrumentAny::CryptoPerpetual(btcusd_bybit);
6790        let order = OrderTestBuilder::new(OrderType::Market)
6791            .instrument_id(btcusd_bybit.id())
6792            .side(OrderSide::Sell)
6793            .quantity(Quantity::from("100000"))
6794            .build();
6795        let commission = calculate_commission(
6796            &btcusd_bybit,
6797            order.quantity(),
6798            Price::from("10000.0"),
6799            None,
6800            dec!(0.00075),
6801        );
6802        let fill = TestOrderEventStubs::filled(
6803            &order,
6804            &btcusd_bybit,
6805            None,
6806            Some(PositionId::from("P-123456")),
6807            Some(Price::from("10000.0")),
6808            None,
6809            None,
6810            Some(commission),
6811            None,
6812            None,
6813        );
6814        let position = Position::new(&btcusd_bybit, fill.into());
6815        let pnl = position
6816            .calculate_pnl(dec!(10000.0), dec!(11000.0), Quantity::from("100000.0"))
6817            .unwrap();
6818        assert_eq!(pnl, native_money(dec!(-10) / dec!(11), Currency::BTC()));
6819        assert_eq!(
6820            position.unrealized_pnl(Price::from("11000.0")).unwrap(),
6821            native_money(dec!(-10) / dec!(11), Currency::BTC())
6822        );
6823        assert_eq!(position.realized_pnl, Some(Money::from("-0.00750000 BTC")));
6824        assert_eq!(
6825            position.notional_value(Price::from("11000.0")),
6826            native_money(dec!(100) / dec!(11), Currency::BTC())
6827        );
6828    }
6829
6830    #[rstest]
6831    #[case("0.030", "0.001 BTC", "0.003 BTC", "0.00098 BTC")]
6832    #[case("0.000", "-0.002 BTC", "0 BTC", "-0.00202 BTC")]
6833    fn test_calculate_pnl_for_inverse_option_values_premium_in_base(
6834        mut crypto_option_btc_deribit: CryptoOption,
6835        #[case] close_px: &str,
6836        #[case] expected_unrealized_pnl: &str,
6837        #[case] expected_notional: &str,
6838        #[case] expected_realized_pnl: &str,
6839    ) {
6840        crypto_option_btc_deribit.is_inverse = true;
6841        crypto_option_btc_deribit.multiplier = Quantity::from("0.01");
6842        let option = InstrumentAny::CryptoOption(crypto_option_btc_deribit);
6843        let open_order = OrderTestBuilder::new(OrderType::Market)
6844            .instrument_id(option.id())
6845            .side(OrderSide::Buy)
6846            .quantity(Quantity::from("10.0"))
6847            .build();
6848        let close_order = OrderTestBuilder::new(OrderType::Market)
6849            .instrument_id(option.id())
6850            .side(OrderSide::Sell)
6851            .quantity(Quantity::from("10.0"))
6852            .build();
6853        let open_fill = TestOrderEventStubs::filled(
6854            &open_order,
6855            &option,
6856            Some(TradeId::new("1")),
6857            None,
6858            Some(Price::from("0.020")),
6859            None,
6860            None,
6861            Some(Money::from("0.00001 BTC")),
6862            None,
6863            None,
6864        );
6865        let close_fill = TestOrderEventStubs::filled(
6866            &close_order,
6867            &option,
6868            Some(TradeId::new("2")),
6869            None,
6870            Some(Price::from(close_px)),
6871            None,
6872            None,
6873            Some(Money::from("0.00001 BTC")),
6874            None,
6875            None,
6876        );
6877        let mut position = Position::new(&option, open_fill.into());
6878        let unrealized_pnl = position.unrealized_pnl(Price::from(close_px)).unwrap();
6879        let notional = position.notional_value(Price::from(close_px));
6880
6881        position.apply(&close_fill.into());
6882
6883        assert_eq!(unrealized_pnl, Money::from(expected_unrealized_pnl));
6884        assert_eq!(notional, Money::from(expected_notional));
6885        assert_eq!(
6886            position.realized_pnl,
6887            Some(Money::from(expected_realized_pnl))
6888        );
6889    }
6890
6891    #[rstest]
6892    fn test_calculate_pnl_scales_by_contract_multiplier(
6893        mut btcusd_bybit: CryptoPerpetual,
6894        mut crypto_perpetual_ethusdt: CryptoPerpetual,
6895    ) {
6896        btcusd_bybit.multiplier = Quantity::from(10);
6897        let btcusd_bybit = InstrumentAny::CryptoPerpetual(btcusd_bybit);
6898        let inverse_order = OrderTestBuilder::new(OrderType::Market)
6899            .instrument_id(btcusd_bybit.id())
6900            .side(OrderSide::Sell)
6901            .quantity(Quantity::from("100000"))
6902            .build();
6903        let inverse_fill = TestOrderEventStubs::filled(
6904            &inverse_order,
6905            &btcusd_bybit,
6906            None,
6907            Some(PositionId::from("P-MULTIPLIER-INVERSE")),
6908            Some(Price::from("10000.0")),
6909            None,
6910            None,
6911            None,
6912            None,
6913            None,
6914        );
6915        let inverse_position = Position::new(&btcusd_bybit, inverse_fill.into());
6916
6917        assert_eq!(
6918            inverse_position
6919                .calculate_pnl(dec!(10000.0), dec!(11000.0), Quantity::from("100000.0"))
6920                .unwrap(),
6921            native_money(dec!(-100) / dec!(11), Currency::BTC())
6922        );
6923
6924        crypto_perpetual_ethusdt.multiplier = Quantity::from(10);
6925        let ethusdt = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt);
6926        let linear_order = OrderTestBuilder::new(OrderType::Market)
6927            .instrument_id(ethusdt.id())
6928            .side(OrderSide::Buy)
6929            .quantity(Quantity::from("2.000"))
6930            .build();
6931        let linear_fill = TestOrderEventStubs::filled(
6932            &linear_order,
6933            &ethusdt,
6934            None,
6935            Some(PositionId::from("P-MULTIPLIER-LINEAR")),
6936            Some(Price::from("1000.00")),
6937            None,
6938            None,
6939            None,
6940            None,
6941            None,
6942        );
6943        let linear_position = Position::new(&ethusdt, linear_fill.into());
6944
6945        assert_eq!(
6946            linear_position
6947                .calculate_pnl(dec!(1000.0), dec!(1100.0), Quantity::from("2.000"))
6948                .unwrap(),
6949            Money::new(2000.0, linear_position.settlement_currency)
6950        );
6951    }
6952
6953    #[rstest]
6954    fn test_try_notional_value_for_inverse_zero_price_returns_error(btcusd_bybit: CryptoPerpetual) {
6955        let btcusd_bybit = InstrumentAny::CryptoPerpetual(btcusd_bybit);
6956        let order = OrderTestBuilder::new(OrderType::Market)
6957            .instrument_id(btcusd_bybit.id())
6958            .side(OrderSide::Sell)
6959            .quantity(Quantity::from("100000"))
6960            .build();
6961        let fill = TestOrderEventStubs::filled(
6962            &order,
6963            &btcusd_bybit,
6964            None,
6965            Some(PositionId::from("P-ZERO-PRICE")),
6966            Some(Price::from("10000.0")),
6967            None,
6968            None,
6969            None,
6970            None,
6971            None,
6972        );
6973        let mut position = Position::new(&btcusd_bybit, fill.into());
6974
6975        let result = position.try_notional_value(Price::new(0.0, 1));
6976
6977        assert_eq!(
6978            result.unwrap_err().to_string(),
6979            "price must be positive for inverse notional valuation"
6980        );
6981        assert!(
6982            position
6983                .try_calculate_pnl(dec!(10_000.0), dec!(0.0), position.quantity)
6984                .is_err()
6985        );
6986        assert!(position.try_unrealized_pnl(Price::new(0.0, 1)).is_err());
6987        assert!(position.try_total_pnl(Price::new(0.0, 1)).is_err());
6988        assert!(position.try_unrealized_pnl(Price::new(-1.0, 1)).is_err());
6989        assert!(
6990            position
6991                .calculate_pnl(dec!(10_000.0), dec!(0.0), position.quantity)
6992                .is_err()
6993        );
6994        assert!(position.unrealized_pnl(Price::new(0.0, 1)).is_err());
6995        assert!(position.total_pnl(Price::new(0.0, 1)).is_err());
6996
6997        position.base_currency = None;
6998        let result = position.try_notional_value(Price::from("10000.0"));
6999
7000        assert_eq!(
7001            result.unwrap_err().to_string(),
7002            "inverse position BTCUSD.BYBIT has no base currency"
7003        );
7004        assert!(position.try_unrealized_pnl(Price::from("10000.0")).is_err());
7005    }
7006
7007    #[rstest]
7008    fn test_calculate_avg_px_zero_quantity_paths(stub_position_long: Position) {
7009        let mut position = stub_position_long;
7010        let mut fill = position.events[0].clone();
7011        position.signed_qty = Decimal::ZERO;
7012        position.quantity = Quantity::zero(position.size_precision);
7013        position.cost_open = Decimal::ZERO;
7014        fill.last_qty = Quantity::zero(position.size_precision);
7015        assert!(
7016            position
7017                .handle_order_fill(&fill, fill.last_px.as_decimal(), Decimal::ZERO)
7018                .is_err()
7019        );
7020        fill.last_qty = Quantity::from(5);
7021        fill.last_px = Price::from("2");
7022        position.handle_order_fill(&fill, dec!(2), dec!(5)).unwrap();
7023        assert_eq!(position.avg_px_open, dec!(2));
7024        assert_eq!(position.cost_open, dec!(10));
7025    }
7026
7027    #[rstest]
7028    fn test_calculate_return_with_zero_open_price(stub_position_long: Position) {
7029        assert_eq!(
7030            stub_position_long.calculate_return(Decimal::ZERO, dec!(1.5)),
7031            0.0
7032        );
7033        assert_eq!(stub_position_long.calculate_return(dec!(2), dec!(3)), 0.5);
7034    }
7035
7036    #[rstest]
7037    fn test_calculate_points_inverse_rejects_non_positive_prices(btcusd_bybit: CryptoPerpetual) {
7038        let btcusd_bybit = InstrumentAny::CryptoPerpetual(btcusd_bybit);
7039        let order = OrderTestBuilder::new(OrderType::Market)
7040            .instrument_id(btcusd_bybit.id())
7041            .side(OrderSide::Sell)
7042            .quantity(Quantity::from("100000"))
7043            .build();
7044        let fill = TestOrderEventStubs::filled(
7045            &order,
7046            &btcusd_bybit,
7047            None,
7048            Some(PositionId::from("P-INVERSE-GUARD")),
7049            Some(Price::from("10000.0")),
7050            None,
7051            None,
7052            None,
7053            None,
7054            None,
7055        );
7056        let position = Position::new(&btcusd_bybit, fill.into());
7057
7058        for (open, close) in [
7059            (dec!(-1), dec!(10000)),
7060            (dec!(10000), dec!(-1)),
7061            (Decimal::ZERO, dec!(10000)),
7062            (dec!(10000), Decimal::ZERO),
7063        ] {
7064            assert!(
7065                position
7066                    .try_calculate_pnl(open, close, position.quantity)
7067                    .is_err()
7068            );
7069        }
7070
7071        assert!(
7072            position
7073                .try_calculate_pnl(dec!(0.0000000000000001), dec!(10000), position.quantity)
7074                .is_err()
7075        );
7076    }
7077
7078    #[rstest]
7079    fn test_calculate_pnl_for_inverse2(ethusd_bybit: CryptoPerpetual) {
7080        let ethusd_bybit = InstrumentAny::CryptoPerpetual(ethusd_bybit);
7081        let order = OrderTestBuilder::new(OrderType::Market)
7082            .instrument_id(ethusd_bybit.id())
7083            .side(OrderSide::Sell)
7084            .quantity(Quantity::from("100000"))
7085            .build();
7086        let commission = calculate_commission(
7087            &ethusd_bybit,
7088            order.quantity(),
7089            Price::from("375.95"),
7090            None,
7091            dec!(0.00075),
7092        );
7093        let fill = TestOrderEventStubs::filled(
7094            &order,
7095            &ethusd_bybit,
7096            None,
7097            Some(PositionId::from("P-123456")),
7098            Some(Price::from("375.95")),
7099            None,
7100            None,
7101            Some(commission),
7102            None,
7103            None,
7104        );
7105        let position = Position::new(&ethusd_bybit, fill.into());
7106
7107        assert_eq!(
7108            position.unrealized_pnl(Price::from("370.00")).unwrap(),
7109            native_money(dec!(1190000) / dec!(278203), Currency::ETH())
7110        );
7111        assert_eq!(
7112            position.notional_value(Price::from("370.00")),
7113            native_money(dec!(10000) / dec!(37), Currency::ETH())
7114        );
7115    }
7116
7117    #[rstest]
7118    fn test_notional_value_for_quanto_uses_settlement_currency(ethbtc_quanto: CryptoFuture) {
7119        let instrument = InstrumentAny::CryptoFuture(ethbtc_quanto);
7120        let order = OrderTestBuilder::new(OrderType::Market)
7121            .instrument_id(instrument.id())
7122            .side(OrderSide::Buy)
7123            .quantity(Quantity::from("5"))
7124            .build();
7125        let price = Price::from("0.03600");
7126        let fill = TestOrderEventStubs::filled(
7127            &order,
7128            &instrument,
7129            None,
7130            Some(PositionId::from("P-QUANTO-NOTIONAL")),
7131            Some(price),
7132            None,
7133            None,
7134            None,
7135            None,
7136            None,
7137        );
7138        let position = Position::new(&instrument, fill.into());
7139        let position_notional = position.notional_value(price);
7140        let instrument_notional =
7141            instrument.calculate_notional_value(position.quantity, price, None);
7142
7143        assert_eq!(position_notional, instrument_notional);
7144        assert_eq!(position_notional, Money::from("0.18 USDT"));
7145    }
7146
7147    #[rstest]
7148    fn test_calculate_unrealized_pnl_for_long(currency_pair_btcusdt: CurrencyPair) {
7149        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
7150        let order1 = OrderTestBuilder::new(OrderType::Market)
7151            .instrument_id(btcusdt.id())
7152            .side(OrderSide::Buy)
7153            .quantity(Quantity::from("2.000000"))
7154            .build();
7155        let order2 = OrderTestBuilder::new(OrderType::Market)
7156            .instrument_id(btcusdt.id())
7157            .side(OrderSide::Buy)
7158            .quantity(Quantity::from("2.000000"))
7159            .build();
7160        let commission1 = calculate_commission(
7161            &btcusdt,
7162            order1.quantity(),
7163            Price::from("10500.0"),
7164            None,
7165            dec!(0.001),
7166        );
7167        let fill1 = TestOrderEventStubs::filled(
7168            &order1,
7169            &btcusdt,
7170            Some(TradeId::new("1")),
7171            Some(PositionId::new("P-123456")),
7172            Some(Price::from("10500.00")),
7173            None,
7174            None,
7175            Some(commission1),
7176            None,
7177            None,
7178        );
7179        let commission2 = calculate_commission(
7180            &btcusdt,
7181            order2.quantity(),
7182            Price::from("10500.0"),
7183            None,
7184            dec!(0.001),
7185        );
7186        let fill2 = TestOrderEventStubs::filled(
7187            &order2,
7188            &btcusdt,
7189            Some(TradeId::new("2")),
7190            Some(PositionId::new("P-123456")),
7191            Some(Price::from("10500.00")),
7192            None,
7193            None,
7194            Some(commission2),
7195            None,
7196            None,
7197        );
7198        let mut position = Position::new(&btcusdt, fill1.into());
7199        position.apply(&fill2.into());
7200        let pnl = position.unrealized_pnl(Price::from("11505.60")).unwrap();
7201        assert_eq!(pnl, Money::from("4022.40000000 USDT"));
7202        assert_eq!(
7203            position.realized_pnl,
7204            Some(Money::from("-42.00000000 USDT"))
7205        );
7206        assert_eq!(
7207            position.commissions(),
7208            vec![Money::from("42.00000000 USDT")]
7209        );
7210    }
7211
7212    #[rstest]
7213    fn test_calculate_unrealized_pnl_for_short(currency_pair_btcusdt: CurrencyPair) {
7214        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
7215        let order = OrderTestBuilder::new(OrderType::Market)
7216            .instrument_id(btcusdt.id())
7217            .side(OrderSide::Sell)
7218            .quantity(Quantity::from("5.912000"))
7219            .build();
7220        let commission = calculate_commission(
7221            &btcusdt,
7222            order.quantity(),
7223            Price::from("10505.60"),
7224            None,
7225            dec!(0.001),
7226        );
7227        let fill = TestOrderEventStubs::filled(
7228            &order,
7229            &btcusdt,
7230            Some(TradeId::new("1")),
7231            Some(PositionId::new("P-123456")),
7232            Some(Price::from("10505.60")),
7233            None,
7234            None,
7235            Some(commission),
7236            None,
7237            None,
7238        );
7239        let position = Position::new(&btcusdt, fill.into());
7240        let pnl = position.unrealized_pnl(Price::from("10407.15")).unwrap();
7241        assert_eq!(pnl, Money::from("582.03640000 USDT"));
7242        assert_eq!(
7243            position.realized_pnl,
7244            Some(Money::from("-62.10910720 USDT"))
7245        );
7246        assert_eq!(
7247            position.commissions(),
7248            vec![Money::from("62.10910720 USDT")]
7249        );
7250    }
7251
7252    #[rstest]
7253    fn test_calculate_unrealized_pnl_for_long_inverse(btcusd_bybit: CryptoPerpetual) {
7254        let btcusd_bybit = InstrumentAny::CryptoPerpetual(btcusd_bybit);
7255        let order = OrderTestBuilder::new(OrderType::Market)
7256            .instrument_id(btcusd_bybit.id())
7257            .side(OrderSide::Buy)
7258            .quantity(Quantity::from("100000"))
7259            .build();
7260        let commission = calculate_commission(
7261            &btcusd_bybit,
7262            order.quantity(),
7263            Price::from("10500.0"),
7264            None,
7265            dec!(0.00075),
7266        );
7267        let fill = TestOrderEventStubs::filled(
7268            &order,
7269            &btcusd_bybit,
7270            Some(TradeId::new("1")),
7271            Some(PositionId::new("P-123456")),
7272            Some(Price::from("10500.00")),
7273            None,
7274            None,
7275            Some(commission),
7276            None,
7277            None,
7278        );
7279
7280        let position = Position::new(&btcusd_bybit, fill.into());
7281        let pnl = position.unrealized_pnl(Price::from("11505.60")).unwrap();
7282        assert_eq!(
7283            pnl,
7284            native_money(dec!(41900) / dec!(50337), Currency::BTC())
7285        );
7286        assert_eq!(position.realized_pnl, Some(Money::from("-0.00714286 BTC")));
7287        assert_eq!(position.commissions(), vec![Money::from("0.00714286 BTC")]);
7288    }
7289
7290    #[rstest]
7291    fn test_calculate_unrealized_pnl_for_short_inverse(btcusd_bybit: CryptoPerpetual) {
7292        let btcusd_bybit = InstrumentAny::CryptoPerpetual(btcusd_bybit);
7293        let order = OrderTestBuilder::new(OrderType::Market)
7294            .instrument_id(btcusd_bybit.id())
7295            .side(OrderSide::Sell)
7296            .quantity(Quantity::from("1250000"))
7297            .build();
7298        let commission = calculate_commission(
7299            &btcusd_bybit,
7300            order.quantity(),
7301            Price::from("15500.00"),
7302            None,
7303            dec!(0.00075),
7304        );
7305        let fill = TestOrderEventStubs::filled(
7306            &order,
7307            &btcusd_bybit,
7308            Some(TradeId::new("1")),
7309            Some(PositionId::new("P-123456")),
7310            Some(Price::from("15500.00")),
7311            None,
7312            None,
7313            Some(commission),
7314            None,
7315            None,
7316        );
7317        let position = Position::new(&btcusd_bybit, fill.into());
7318        let pnl = position.unrealized_pnl(Price::from("12506.65")).unwrap();
7319
7320        assert_eq!(
7321            pnl,
7322            native_money(dec!(149667500) / dec!(7754123), Currency::BTC())
7323        );
7324        assert_eq!(position.realized_pnl, Some(Money::from("-0.06048387 BTC")));
7325        assert_eq!(position.commissions(), vec![Money::from("0.06048387 BTC")]);
7326    }
7327
7328    #[rstest]
7329    #[case(OrderSide::Buy, 25, 25.0)]
7330    #[case(OrderSide::Sell,25,-25.0)]
7331    fn test_signed_qty_decimal_qty_for_equity(
7332        #[case] order_side: OrderSide,
7333        #[case] quantity: i64,
7334        #[case] expected: f64,
7335        audusd_sim: CurrencyPair,
7336    ) {
7337        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7338        let order = OrderTestBuilder::new(OrderType::Market)
7339            .instrument_id(audusd_sim.id())
7340            .side(order_side)
7341            .quantity(Quantity::from(quantity))
7342            .build();
7343
7344        let commission = calculate_commission(
7345            &audusd_sim,
7346            order.quantity(),
7347            Price::from("1.0"),
7348            None,
7349            dec!(0.00002),
7350        );
7351        let fill = TestOrderEventStubs::filled(
7352            &order,
7353            &audusd_sim,
7354            None,
7355            Some(PositionId::from("P-123456")),
7356            None,
7357            None,
7358            None,
7359            Some(commission),
7360            None,
7361            None,
7362        );
7363        let position = Position::new(&audusd_sim, fill.into());
7364        assert_eq!(position.signed_qty, Decimal::try_from(expected).unwrap());
7365    }
7366
7367    #[rstest]
7368    fn test_position_with_commission_none(audusd_sim: CurrencyPair) {
7369        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7370        let fill = OrderFilledSpec::builder()
7371            .position_id(PositionId::from("1"))
7372            .build();
7373
7374        let position = Position::new(&audusd_sim, fill);
7375        assert_eq!(position.realized_pnl, Some(Money::from("0 USD")));
7376    }
7377
7378    #[rstest]
7379    fn test_position_with_commission_zero(audusd_sim: CurrencyPair) {
7380        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7381        let fill = OrderFilledSpec::builder()
7382            .position_id(PositionId::from("1"))
7383            .commission(Money::from("0 USD"))
7384            .build();
7385
7386        let position = Position::new(&audusd_sim, fill);
7387        assert_eq!(position.realized_pnl, Some(Money::from("0 USD")));
7388    }
7389
7390    #[rstest]
7391    fn test_cache_purge_order_events(#[values(true, false)] retain_replay: bool) {
7392        let audusd_sim = audusd_sim();
7393        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7394
7395        let order1 = OrderTestBuilder::new(OrderType::Market)
7396            .client_order_id(ClientOrderId::new("O-1"))
7397            .instrument_id(audusd_sim.id())
7398            .side(OrderSide::Buy)
7399            .quantity(Quantity::from(50_000))
7400            .build();
7401
7402        let order2 = OrderTestBuilder::new(OrderType::Market)
7403            .client_order_id(ClientOrderId::new("O-2"))
7404            .instrument_id(audusd_sim.id())
7405            .side(OrderSide::Buy)
7406            .quantity(Quantity::from(50_000))
7407            .build();
7408
7409        let position_id = PositionId::new("P-123456");
7410
7411        let fill1 = TestOrderEventStubs::filled(
7412            &order1,
7413            &audusd_sim,
7414            Some(TradeId::new("1")),
7415            Some(position_id),
7416            Some(Price::from("1.00001")),
7417            None,
7418            None,
7419            None,
7420            None,
7421            None,
7422        );
7423
7424        let mut position = Position::new(&audusd_sim, fill1.into());
7425
7426        let fill2 = TestOrderEventStubs::filled(
7427            &order2,
7428            &audusd_sim,
7429            Some(TradeId::new("2")),
7430            Some(position_id),
7431            Some(Price::from("1.00002")),
7432            None,
7433            None,
7434            None,
7435            None,
7436            None,
7437        );
7438
7439        position.apply(&fill2.into());
7440        if !retain_replay {
7441            position.replay_events.clear();
7442        }
7443
7444        position
7445            .purge_events_for_order(order1.client_order_id())
7446            .unwrap();
7447
7448        assert_eq!(position.events.len(), 1);
7449        assert_eq!(position.trade_ids.len(), 1);
7450        assert_eq!(position.events[0].client_order_id, order2.client_order_id());
7451        assert!(position.trade_ids.contains(&TradeId::new("2")));
7452    }
7453
7454    #[rstest]
7455    fn test_purge_all_fills_preserves_legacy_metadata(audusd_sim: CurrencyPair) {
7456        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
7457        let opening = OrderFilledSpec::builder()
7458            .instrument_id(instrument.id())
7459            .client_order_id(ClientOrderId::from("O-PURGE"))
7460            .trade_id(TradeId::from("T-OPEN"))
7461            .order_side(OrderSide::Buy)
7462            .last_qty(Quantity::from(7))
7463            .last_px(Price::from("1.23456"))
7464            .currency(Currency::USD())
7465            .position_id(PositionId::from("P-PURGE"))
7466            .ts_event(UnixNanos::from(11))
7467            .ts_init(UnixNanos::from(12))
7468            .build();
7469        let mut closing = opening.clone();
7470        closing.trade_id = TradeId::from("T-CLOSE");
7471        closing.event_id = uuid4();
7472        closing.order_side = OrderSide::Sell;
7473        closing.last_px = Price::from("1.34567");
7474        closing.ts_event = UnixNanos::from(23);
7475        let mut position = Position::new(&instrument, opening);
7476        position.apply(&closing);
7477
7478        position
7479            .purge_events_for_order(ClientOrderId::from("O-PURGE"))
7480            .unwrap();
7481
7482        assert_eq!(position.peak_qty, Quantity::from(7));
7483        assert_eq!(position.avg_px_open, dec!(1.23456));
7484        assert_eq!(position.opening_order_id, ClientOrderId::from("O-PURGE"));
7485        assert_eq!(
7486            position.closing_order_id,
7487            Some(ClientOrderId::from("O-PURGE"))
7488        );
7489        assert_eq!(position.entry, OrderSide::Buy);
7490        assert_eq!(position.ts_init, UnixNanos::from(12));
7491        assert_eq!(position.quantity, Quantity::zero(position.size_precision));
7492        assert_eq!(position.cost_open, Decimal::ZERO);
7493        assert_eq!(position.cost_close, Decimal::ZERO);
7494        assert_eq!(position.qty_closed, Decimal::ZERO);
7495        assert_eq!(position.avg_px_close, None);
7496        assert_eq!(position.realized_pnl, None);
7497        assert_eq!(position.realized_pnl_remainder, Decimal::ZERO);
7498        assert_eq!(position.side, PositionSide::Flat);
7499        assert_eq!(position.ts_closed, Some(UnixNanos::default()));
7500        assert!(position.events.is_empty());
7501        assert!(position.replay_events.is_empty());
7502    }
7503
7504    #[rstest]
7505    fn test_purge_all_events_returns_none_for_last_event_and_trade_id() {
7506        let audusd_sim = audusd_sim();
7507        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7508
7509        let order = OrderTestBuilder::new(OrderType::Market)
7510            .client_order_id(ClientOrderId::new("O-1"))
7511            .instrument_id(audusd_sim.id())
7512            .side(OrderSide::Buy)
7513            .quantity(Quantity::from(100_000))
7514            .build();
7515
7516        let position_id = PositionId::new("P-123456");
7517        let fill = TestOrderEventStubs::filled(
7518            &order,
7519            &audusd_sim,
7520            Some(TradeId::new("1")),
7521            Some(position_id),
7522            Some(Price::from("1.00050")),
7523            None,
7524            None,
7525            None,
7526            Some(UnixNanos::from(1_000_000_000)), // Explicit non-zero timestamp
7527            None,
7528        );
7529
7530        let mut position = Position::new(&audusd_sim, fill.into());
7531
7532        assert_eq!(position.events.len(), 1);
7533        assert!(position.last_event().is_some());
7534        assert!(position.last_trade_id().is_some());
7535
7536        // Store original timestamps (should be non-zero)
7537        let original_ts_opened = position.ts_opened;
7538        let original_ts_last = position.ts_last;
7539        assert_ne!(original_ts_opened, UnixNanos::default());
7540        assert_ne!(original_ts_last, UnixNanos::default());
7541
7542        position
7543            .purge_events_for_order(order.client_order_id())
7544            .unwrap();
7545
7546        assert_eq!(position.events.len(), 0);
7547        assert_eq!(position.trade_ids.len(), 0);
7548        assert!(position.last_event().is_none());
7549        assert!(position.last_trade_id().is_none());
7550
7551        // Verify timestamps are zeroed - empty shell has no meaningful history
7552        // ts_closed is set to Some(0) so position reports as closed and is eligible for purge
7553        assert_eq!(position.ts_opened, UnixNanos::default());
7554        assert_eq!(position.ts_last, UnixNanos::default());
7555        assert_eq!(position.ts_closed, Some(UnixNanos::default()));
7556        assert_eq!(position.duration_ns, DurationNanos::default());
7557
7558        // Verify empty shell reports as closed (this was the bug we fixed!)
7559        // is_closed() must return true so cache purge logic recognizes empty shells
7560        assert!(position.is_closed());
7561        assert!(!position.is_open());
7562        assert_eq!(position.side, PositionSide::Flat);
7563    }
7564
7565    #[rstest]
7566    fn test_revive_from_empty_shell(audusd_sim: CurrencyPair) {
7567        // Test adding a fill to an empty shell position
7568        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7569
7570        // Create and then purge position to get empty shell
7571        let order1 = OrderTestBuilder::new(OrderType::Market)
7572            .instrument_id(audusd_sim.id())
7573            .side(OrderSide::Buy)
7574            .quantity(Quantity::from(100_000))
7575            .build();
7576
7577        let fill1 = TestOrderEventStubs::filled(
7578            &order1,
7579            &audusd_sim,
7580            None,
7581            Some(PositionId::new("P-1")),
7582            Some(Price::from("1.00000")),
7583            None,
7584            None,
7585            None,
7586            Some(UnixNanos::from(1_000_000_000)),
7587            None,
7588        );
7589
7590        let mut position = Position::new(&audusd_sim, fill1.into());
7591        position
7592            .purge_events_for_order(order1.client_order_id())
7593            .unwrap();
7594
7595        // Verify it's an empty shell
7596        assert!(position.is_closed());
7597        assert_eq!(position.ts_closed, Some(UnixNanos::default()));
7598        assert_eq!(position.event_count(), 0);
7599
7600        // Add new fill to revive the position
7601        let order2 = OrderTestBuilder::new(OrderType::Market)
7602            .instrument_id(audusd_sim.id())
7603            .side(OrderSide::Buy)
7604            .quantity(Quantity::from(50_000))
7605            .build();
7606
7607        let fill2 = TestOrderEventStubs::filled(
7608            &order2,
7609            &audusd_sim,
7610            None,
7611            Some(PositionId::new("P-1")),
7612            Some(Price::from("1.00020")),
7613            None,
7614            None,
7615            None,
7616            Some(UnixNanos::from(3_000_000_000)),
7617            None,
7618        );
7619
7620        let fill2_typed: OrderFilled = fill2.clone().into();
7621        position.apply(&fill2_typed);
7622
7623        // Position should be alive with new timestamps
7624        assert!(position.is_long());
7625        assert!(!position.is_closed());
7626        assert!(position.ts_closed.is_none());
7627        assert_eq!(position.ts_opened, fill2.ts_event());
7628        assert_eq!(position.ts_last, fill2.ts_event());
7629        assert_eq!(position.event_count(), 1);
7630        assert_eq!(position.quantity, Quantity::from(50_000));
7631    }
7632
7633    #[rstest]
7634    fn test_empty_shell_position_invariants(audusd_sim: CurrencyPair) {
7635        // Property-based test: Any position with event_count == 0 must satisfy invariants
7636        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7637
7638        let order = OrderTestBuilder::new(OrderType::Market)
7639            .instrument_id(audusd_sim.id())
7640            .side(OrderSide::Buy)
7641            .quantity(Quantity::from(100_000))
7642            .build();
7643
7644        let fill = TestOrderEventStubs::filled(
7645            &order,
7646            &audusd_sim,
7647            None,
7648            Some(PositionId::new("P-1")),
7649            Some(Price::from("1.00000")),
7650            None,
7651            None,
7652            None,
7653            Some(UnixNanos::from(1_000_000_000)),
7654            None,
7655        );
7656
7657        let mut position = Position::new(&audusd_sim, fill.into());
7658        position
7659            .purge_events_for_order(order.client_order_id())
7660            .unwrap();
7661
7662        // INVARIANTS: When event_count == 0, the following MUST be true
7663        assert_eq!(
7664            position.event_count(),
7665            0,
7666            "Precondition: event_count must be 0"
7667        );
7668
7669        // Invariant 1: Position must report as closed
7670        assert!(
7671            position.is_closed(),
7672            "INV1: Empty shell must report is_closed() == true"
7673        );
7674        assert!(
7675            !position.is_open(),
7676            "INV1: Empty shell must report is_open() == false"
7677        );
7678
7679        // Invariant 2: Position must be FLAT
7680        assert_eq!(
7681            position.side,
7682            PositionSide::Flat,
7683            "INV2: Empty shell must be FLAT"
7684        );
7685
7686        // Invariant 3: ts_closed must be Some (not None)
7687        assert!(
7688            position.ts_closed.is_some(),
7689            "INV3: Empty shell must have ts_closed.is_some()"
7690        );
7691        assert_eq!(
7692            position.ts_closed,
7693            Some(UnixNanos::default()),
7694            "INV3: Empty shell ts_closed must be 0"
7695        );
7696
7697        // Invariant 4: All lifecycle timestamps must be zeroed
7698        assert_eq!(
7699            position.ts_opened,
7700            UnixNanos::default(),
7701            "INV4: Empty shell ts_opened must be 0"
7702        );
7703        assert_eq!(
7704            position.ts_last,
7705            UnixNanos::default(),
7706            "INV4: Empty shell ts_last must be 0"
7707        );
7708        assert_eq!(
7709            position.duration_ns,
7710            DurationNanos::default(),
7711            "INV4: Empty shell duration_ns must be 0"
7712        );
7713
7714        // Invariant 5: Quantity must be zero
7715        assert_eq!(
7716            position.quantity,
7717            Quantity::zero(audusd_sim.size_precision()),
7718            "INV5: Empty shell quantity must be 0"
7719        );
7720
7721        // Invariant 6: No events or trade IDs
7722        assert!(
7723            position.events.is_empty(),
7724            "INV6: Empty shell must have no events"
7725        );
7726        assert!(
7727            position.trade_ids.is_empty(),
7728            "INV6: Empty shell must have no trade IDs"
7729        );
7730        assert!(
7731            position.last_event().is_none(),
7732            "INV6: Empty shell must have no last event"
7733        );
7734        assert!(
7735            position.last_trade_id().is_none(),
7736            "INV6: Empty shell must have no last trade ID"
7737        );
7738    }
7739
7740    #[rstest]
7741    fn test_position_pnl_precision_with_very_small_amounts(audusd_sim: CurrencyPair) {
7742        // Tests behavior with very small commission amounts
7743        // NOTE: Amounts below f64 epsilon (~1e-15) may be lost to precision
7744        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7745        let order = OrderTestBuilder::new(OrderType::Market)
7746            .instrument_id(audusd_sim.id())
7747            .side(OrderSide::Buy)
7748            .quantity(Quantity::from(100))
7749            .build();
7750
7751        // Test with a commission that won't be lost to Money precision (0.01 USD)
7752        let small_commission = Money::new(0.01, Currency::USD());
7753        let fill = TestOrderEventStubs::filled(
7754            &order,
7755            &audusd_sim,
7756            None,
7757            None,
7758            Some(Price::from("1.00001")),
7759            Some(Quantity::from(100)),
7760            None,
7761            Some(small_commission),
7762            None,
7763            None,
7764        );
7765
7766        let position = Position::new(&audusd_sim, fill.into());
7767
7768        // Commission is recorded and preserved in f64 arithmetic
7769        assert_eq!(position.commissions().len(), 1);
7770        let recorded_commission = position.commissions()[0];
7771        assert!(
7772            recorded_commission.as_f64() > 0.0,
7773            "Commission of 0.01 should be preserved"
7774        );
7775
7776        // Realized PnL should include commission (negative)
7777        let realized = position.realized_pnl.unwrap().as_f64();
7778        assert!(
7779            realized < 0.0,
7780            "Realized PnL should be negative due to commission"
7781        );
7782    }
7783
7784    #[rstest]
7785    fn test_position_pnl_precision_with_high_precision_instrument() {
7786        // Tests precision with high-precision crypto instrument
7787        use crate::instruments::stubs::crypto_perpetual_ethusdt;
7788        let ethusdt = crypto_perpetual_ethusdt();
7789        let ethusdt = InstrumentAny::CryptoPerpetual(ethusdt);
7790
7791        // Check instrument precision
7792        let size_precision = ethusdt.size_precision();
7793
7794        let order = OrderTestBuilder::new(OrderType::Market)
7795            .instrument_id(ethusdt.id())
7796            .side(OrderSide::Buy)
7797            .quantity(Quantity::from("1.123456789"))
7798            .build();
7799
7800        let fill = TestOrderEventStubs::filled(
7801            &order,
7802            &ethusdt,
7803            None,
7804            None,
7805            Some(Price::from("2345.123456789")),
7806            Some(Quantity::from("1.123456789")),
7807            None,
7808            Some(Money::from("0.1 USDT")),
7809            None,
7810            None,
7811        );
7812
7813        let position = Position::new(&ethusdt, fill.into());
7814
7815        // Verify high-precision price is preserved in f64 (within tolerance)
7816        let avg_px = position.avg_px_open;
7817        assert_eq!(avg_px, dec!(2345.123456789));
7818
7819        assert_eq!(position.size_precision, size_precision);
7820        assert_eq!(position.quantity.precision, 9);
7821        assert_eq!(position.quantity.as_decimal(), dec!(1.123456789));
7822        assert_eq!(position.signed_qty, dec!(1.123456789));
7823    }
7824
7825    #[rstest]
7826    fn test_position_pnl_accumulation_across_many_fills(audusd_sim: CurrencyPair) {
7827        // Tests precision drift across 100 fills
7828        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7829        let order = OrderTestBuilder::new(OrderType::Market)
7830            .instrument_id(audusd_sim.id())
7831            .side(OrderSide::Buy)
7832            .quantity(Quantity::from(1000))
7833            .build();
7834
7835        let initial_fill = TestOrderEventStubs::filled(
7836            &order,
7837            &audusd_sim,
7838            Some(TradeId::new("1")),
7839            None,
7840            Some(Price::from("1.00000")),
7841            Some(Quantity::from(10)),
7842            None,
7843            Some(Money::from("0.01 USD")),
7844            None,
7845            None,
7846        );
7847
7848        let mut position = Position::new(&audusd_sim, initial_fill.into());
7849
7850        // Apply 99 more fills with varying prices
7851        for i in 2..=100 {
7852            let price_offset = f64::from(i) * 0.00001;
7853            let fill = TestOrderEventStubs::filled(
7854                &order,
7855                &audusd_sim,
7856                Some(TradeId::new(i.to_string())),
7857                None,
7858                Some(Price::from(&format!("{:.5}", 1.0 + price_offset))),
7859                Some(Quantity::from(10)),
7860                None,
7861                Some(Money::from("0.01 USD")),
7862                None,
7863                None,
7864            );
7865            position.apply(&fill.into());
7866        }
7867
7868        // Verify we accumulated 100 fills
7869        assert_eq!(position.events.len(), 100);
7870        assert_eq!(position.quantity, Quantity::from(1000));
7871
7872        // Verify commissions accumulated (should be 100 * 0.01 = 1.0 USD)
7873        let total_commission: f64 = position.commissions().iter().map(Money::as_f64).sum();
7874        assert!(
7875            (total_commission - 1.0).abs() < 1e-10,
7876            "Commission accumulation should be accurate: expected 1.0, was {total_commission}"
7877        );
7878
7879        // Verify average price is reasonable (should be around 1.0005)
7880        let avg_px = position.avg_px_open;
7881        assert!(
7882            avg_px > dec!(1.0) && avg_px < dec!(1.001),
7883            "Average price should be reasonable: got {avg_px}"
7884        );
7885    }
7886
7887    #[rstest]
7888    fn test_position_pnl_with_extreme_price_values(audusd_sim: CurrencyPair) {
7889        // Tests position handling with very large and very small prices
7890        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7891
7892        // Test with very small price
7893        let order_small = OrderTestBuilder::new(OrderType::Market)
7894            .instrument_id(audusd_sim.id())
7895            .side(OrderSide::Buy)
7896            .quantity(Quantity::from(100_000))
7897            .build();
7898
7899        let fill_small = TestOrderEventStubs::filled(
7900            &order_small,
7901            &audusd_sim,
7902            None,
7903            None,
7904            Some(Price::from("0.00001")),
7905            Some(Quantity::from(100_000)),
7906            None,
7907            None,
7908            None,
7909            None,
7910        );
7911
7912        let position_small = Position::new(&audusd_sim, fill_small.into());
7913        assert_eq!(position_small.avg_px_open, dec!(0.00001));
7914
7915        // Verify notional calculation doesn't underflow
7916        let last_price_small = Price::from("0.00002");
7917        let unrealized = position_small.unrealized_pnl(last_price_small).unwrap();
7918        assert!(
7919            unrealized.as_f64() > 0.0,
7920            "Unrealized PnL should be positive when price doubles"
7921        );
7922
7923        // Test with very large price
7924        let order_large = OrderTestBuilder::new(OrderType::Market)
7925            .instrument_id(audusd_sim.id())
7926            .side(OrderSide::Buy)
7927            .quantity(Quantity::from(100))
7928            .build();
7929
7930        let fill_large = TestOrderEventStubs::filled(
7931            &order_large,
7932            &audusd_sim,
7933            None,
7934            None,
7935            Some(Price::from("99999.99999")),
7936            Some(Quantity::from(100)),
7937            None,
7938            None,
7939            None,
7940            None,
7941        );
7942
7943        let position_large = Position::new(&audusd_sim, fill_large.into());
7944        assert!(
7945            (position_large.avg_px_open - dec!(99999.99999)).abs() < dec!(1e-6),
7946            "Large price should be preserved within f64 tolerance"
7947        );
7948    }
7949
7950    #[rstest]
7951    fn test_position_pnl_roundtrip_precision(audusd_sim: CurrencyPair) {
7952        // Tests that opening and closing a position preserves precision
7953        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7954        let buy_order = OrderTestBuilder::new(OrderType::Market)
7955            .instrument_id(audusd_sim.id())
7956            .side(OrderSide::Buy)
7957            .quantity(Quantity::from(100_000))
7958            .build();
7959
7960        let sell_order = OrderTestBuilder::new(OrderType::Market)
7961            .instrument_id(audusd_sim.id())
7962            .side(OrderSide::Sell)
7963            .quantity(Quantity::from(100_000))
7964            .build();
7965
7966        // Open at precise price
7967        let open_fill = TestOrderEventStubs::filled(
7968            &buy_order,
7969            &audusd_sim,
7970            Some(TradeId::new("1")),
7971            None,
7972            Some(Price::from("1.123456")),
7973            None,
7974            None,
7975            Some(Money::from("0.50 USD")),
7976            None,
7977            None,
7978        );
7979
7980        let mut position = Position::new(&audusd_sim, open_fill.into());
7981
7982        // Close at same price (no profit/loss except commission)
7983        let close_fill = TestOrderEventStubs::filled(
7984            &sell_order,
7985            &audusd_sim,
7986            Some(TradeId::new("2")),
7987            None,
7988            Some(Price::from("1.123456")),
7989            None,
7990            None,
7991            Some(Money::from("0.50 USD")),
7992            None,
7993            None,
7994        );
7995
7996        position.apply(&close_fill.into());
7997
7998        // Position should be flat
7999        assert!(position.is_closed());
8000
8001        // Realized PnL should be exactly -1.0 USD (two commissions of 0.50)
8002        let realized = position.realized_pnl.unwrap().as_f64();
8003        assert!(
8004            (realized - (-1.0)).abs() < 1e-10,
8005            "Realized PnL should be exactly -1.0 USD (commissions), was {realized}"
8006        );
8007    }
8008
8009    #[rstest]
8010    fn test_position_commission_in_base_currency_buy() {
8011        // Test that commission in base currency reduces position quantity on buy (SPOT only)
8012        let btc_usdt = currency_pair_btcusdt();
8013        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
8014
8015        let order = OrderTestBuilder::new(OrderType::Market)
8016            .instrument_id(btc_usdt.id())
8017            .side(OrderSide::Buy)
8018            .quantity(Quantity::from("1.0"))
8019            .build();
8020
8021        // Buy 1.0 BTC with 0.001 BTC commission
8022        let fill = match TestOrderEventStubs::filled(
8023            &order,
8024            &btc_usdt,
8025            Some(TradeId::new("1")),
8026            None,
8027            Some(Price::from("50000.0")),
8028            Some(Quantity::from("1.0")),
8029            None,
8030            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
8031            None,
8032            None,
8033        ) {
8034            OrderEventAny::Filled(fill) => fill,
8035            _ => unreachable!(),
8036        };
8037
8038        let position = Position::new(&btc_usdt, fill.clone());
8039        let replayed_position = Position::new(&btc_usdt, fill);
8040
8041        // Position quantity should be 1.0 - 0.001 = 0.999 BTC
8042        assert!(
8043            (position.quantity.as_f64() - 0.999).abs() < 1e-9,
8044            "Position quantity should be 0.999 BTC (1.0 - 0.001 commission), was {}",
8045            position.quantity.as_f64()
8046        );
8047
8048        // Signed qty should also be 0.999
8049        assert!(
8050            (position.signed_qty - dec!(0.999)).abs() < dec!(1e-9),
8051            "Signed qty should be 0.999, was {}",
8052            position.signed_qty
8053        );
8054
8055        // Verify PositionAdjusted event was created
8056        assert_eq!(
8057            position.adjustments.len(),
8058            1,
8059            "Should have 1 adjustment event"
8060        );
8061        let adjustment = &position.adjustments[0];
8062        assert_eq!(
8063            adjustment.adjustment_type,
8064            PositionAdjustmentType::Commission
8065        );
8066        assert_eq!(
8067            adjustment.quantity_change,
8068            Some(rust_decimal_macros::dec!(-0.001))
8069        );
8070        assert_eq!(adjustment.pnl_change, None);
8071        assert_eq!(
8072            adjustment.event_id,
8073            replayed_position.adjustments[0].event_id
8074        );
8075    }
8076
8077    #[rstest]
8078    fn test_tokenized_asset_base_commission_buy_then_close_net_holding() {
8079        let instrument = InstrumentAny::TokenizedAsset(tokenized_asset_aaplx());
8080        let base_currency = instrument.base_currency().unwrap();
8081        let buy = OrderTestBuilder::new(OrderType::Market)
8082            .instrument_id(instrument.id())
8083            .client_order_id(ClientOrderId::from("O-BUY"))
8084            .side(OrderSide::Buy)
8085            .quantity(Quantity::from("1.0000"))
8086            .build();
8087        let OrderEventAny::Filled(buy_fill) = TestOrderEventStubs::filled(
8088            &buy,
8089            &instrument,
8090            Some(TradeId::new("1")),
8091            None,
8092            Some(Price::from("200.00")),
8093            Some(Quantity::from("1.0000")),
8094            None,
8095            Some(Money::new(0.001, base_currency)),
8096            None,
8097            None,
8098        ) else {
8099            unreachable!()
8100        };
8101
8102        let mut position = Position::new(&instrument, buy_fill);
8103
8104        assert_eq!(position.quantity, Quantity::from("0.9990"));
8105        assert_eq!(position.adjustments.len(), 1);
8106        assert_eq!(
8107            position.adjustments[0].adjustment_type,
8108            PositionAdjustmentType::Commission
8109        );
8110        assert_eq!(
8111            position.adjustments[0].quantity_change,
8112            Some(rust_decimal_macros::dec!(-0.001))
8113        );
8114
8115        let sell = OrderTestBuilder::new(OrderType::Market)
8116            .instrument_id(instrument.id())
8117            .client_order_id(ClientOrderId::from("O-SELL"))
8118            .side(OrderSide::Sell)
8119            .quantity(Quantity::from("0.9990"))
8120            .build();
8121        let OrderEventAny::Filled(sell_fill) = TestOrderEventStubs::filled(
8122            &sell,
8123            &instrument,
8124            Some(TradeId::new("2")),
8125            None,
8126            Some(Price::from("210.00")),
8127            Some(Quantity::from("0.9990")),
8128            None,
8129            Some(Money::zero(instrument.quote_currency())),
8130            None,
8131            None,
8132        ) else {
8133            unreachable!()
8134        };
8135
8136        position.apply(&sell_fill);
8137
8138        assert_eq!(position.side, PositionSide::Flat);
8139        assert!(position.quantity.is_zero());
8140        assert!(position.is_closed());
8141    }
8142
8143    #[rstest]
8144    fn test_base_commission_adjustment_id_flips_low_bit_of_fill_id(audusd_sim: CurrencyPair) {
8145        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
8146        let base_currency = instrument.base_currency().unwrap();
8147        let fill = OrderFilledSpec::builder()
8148            .instrument_id(instrument.id())
8149            .client_order_id(ClientOrderId::from("O-1"))
8150            .trade_id(TradeId::from("T-1"))
8151            .order_side(OrderSide::Buy)
8152            .last_qty(Quantity::from(10))
8153            .last_px(Price::from("1.00000"))
8154            .currency(Currency::USD())
8155            .commission(Money::new(2.0, base_currency))
8156            .position_id(PositionId::from("P-COMMISSION"))
8157            .event_id(UUID4::from_str("a1b2c3d4-e5f6-4789-8abc-def012345679").unwrap())
8158            .ts_event(UnixNanos::from(1))
8159            .build();
8160
8161        let position = Position::new(&instrument, fill);
8162
8163        assert_eq!(position.adjustments.len(), 1);
8164        assert_eq!(
8165            position.adjustments[0].event_id,
8166            UUID4::from_str("a1b2c3d4-e5f6-4789-8abc-def012345678").unwrap()
8167        );
8168    }
8169
8170    #[rstest]
8171    fn test_position_commission_in_base_currency_sell() {
8172        // Test that commission in base currency increases short position on sell
8173        let btc_usdt = currency_pair_btcusdt();
8174        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
8175
8176        let order = OrderTestBuilder::new(OrderType::Market)
8177            .instrument_id(btc_usdt.id())
8178            .side(OrderSide::Sell)
8179            .quantity(Quantity::from("1.0"))
8180            .build();
8181
8182        // Sell 1.0 BTC with 0.001 BTC commission
8183        let fill = TestOrderEventStubs::filled(
8184            &order,
8185            &btc_usdt,
8186            Some(TradeId::new("1")),
8187            None,
8188            Some(Price::from("50000.0")),
8189            Some(Quantity::from("1.0")),
8190            None,
8191            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
8192            None,
8193            None,
8194        );
8195
8196        let position = Position::new(&btc_usdt, fill.into());
8197
8198        // Position quantity should be 1.0 + 0.001 = 1.001 BTC
8199        // (you sold 1.0 and paid 0.001 commission, so total short exposure is 1.001)
8200        assert!(
8201            (position.quantity.as_f64() - 1.001).abs() < 1e-9,
8202            "Position quantity should be 1.001 BTC (1.0 + 0.001 commission), was {}",
8203            position.quantity.as_f64()
8204        );
8205
8206        // Signed qty should be -1.001 (short position)
8207        assert!(
8208            (position.signed_qty - (dec!(-1.001))).abs() < dec!(1e-9),
8209            "Signed qty should be -1.001, was {}",
8210            position.signed_qty
8211        );
8212
8213        // Verify PositionAdjusted event was created
8214        assert_eq!(
8215            position.adjustments.len(),
8216            1,
8217            "Should have 1 adjustment event"
8218        );
8219        let adjustment = &position.adjustments[0];
8220        assert_eq!(
8221            adjustment.adjustment_type,
8222            PositionAdjustmentType::Commission
8223        );
8224        // For sell, commission increases the short (negative adjustment)
8225        assert_eq!(
8226            adjustment.quantity_change,
8227            Some(rust_decimal_macros::dec!(-0.001))
8228        );
8229        assert_eq!(adjustment.pnl_change, None);
8230    }
8231
8232    #[rstest]
8233    fn test_position_commission_in_quote_currency_no_adjustment() {
8234        // Test that commission in quote currency does NOT reduce position quantity
8235        let btc_usdt = currency_pair_btcusdt();
8236        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
8237
8238        let order = OrderTestBuilder::new(OrderType::Market)
8239            .instrument_id(btc_usdt.id())
8240            .side(OrderSide::Buy)
8241            .quantity(Quantity::from("1.0"))
8242            .build();
8243
8244        // Buy 1.0 BTC with 50 USDT commission (in quote currency)
8245        let fill = TestOrderEventStubs::filled(
8246            &order,
8247            &btc_usdt,
8248            Some(TradeId::new("1")),
8249            None,
8250            Some(Price::from("50000.0")),
8251            Some(Quantity::from("1.0")),
8252            None,
8253            Some(Money::new(50.0, Currency::USD())),
8254            None,
8255            None,
8256        );
8257
8258        let position = Position::new(&btc_usdt, fill.into());
8259
8260        // Position quantity should be exactly 1.0 BTC (no adjustment)
8261        assert!(
8262            (position.quantity.as_f64() - 1.0).abs() < 1e-9,
8263            "Position quantity should be 1.0 BTC (no adjustment for quote currency commission), was {}",
8264            position.quantity.as_f64()
8265        );
8266
8267        // Verify NO PositionAdjusted event was created (commission in quote currency)
8268        assert_eq!(
8269            position.adjustments.len(),
8270            0,
8271            "Should have no adjustment events for quote currency commission"
8272        );
8273    }
8274
8275    #[rstest]
8276    fn test_position_reset_clears_adjustments() {
8277        // Test that closing and reopening a position clears adjustment history
8278        let btc_usdt = currency_pair_btcusdt();
8279        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
8280
8281        // Open long position with commission adjustment
8282        let buy_order = OrderTestBuilder::new(OrderType::Market)
8283            .instrument_id(btc_usdt.id())
8284            .side(OrderSide::Buy)
8285            .quantity(Quantity::from("1.0"))
8286            .build();
8287
8288        let buy_fill = TestOrderEventStubs::filled(
8289            &buy_order,
8290            &btc_usdt,
8291            Some(TradeId::new("1")),
8292            None,
8293            Some(Price::from("50000.0")),
8294            Some(Quantity::from("1.0")),
8295            None,
8296            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
8297            None,
8298            None,
8299        );
8300
8301        let mut position = Position::new(&btc_usdt, buy_fill.into());
8302        assert_eq!(position.adjustments.len(), 1, "Should have 1 adjustment");
8303
8304        // Close the position (sell the actual quantity, use quote currency commission to avoid complexity)
8305        let sell_order = OrderTestBuilder::new(OrderType::Market)
8306            .instrument_id(btc_usdt.id())
8307            .side(OrderSide::Sell)
8308            .quantity(Quantity::from("0.999"))
8309            .build();
8310
8311        let sell_fill = TestOrderEventStubs::filled(
8312            &sell_order,
8313            &btc_usdt,
8314            Some(TradeId::new("2")),
8315            None,
8316            Some(Price::from("51000.0")),
8317            Some(Quantity::from("0.999")),
8318            None,
8319            Some(Money::new(50.0, Currency::USD())), // Quote currency commission - no adjustment
8320            None,
8321            None,
8322        );
8323
8324        position.apply(&sell_fill.into());
8325        assert_eq!(position.side, PositionSide::Flat);
8326        assert_eq!(
8327            position.adjustments.len(),
8328            1,
8329            "Should still have 1 adjustment (no new one from quote commission)"
8330        );
8331
8332        // Reopen the position - adjustments should be cleared
8333        let buy_order2 = OrderTestBuilder::new(OrderType::Market)
8334            .instrument_id(btc_usdt.id())
8335            .side(OrderSide::Buy)
8336            .quantity(Quantity::from("2.0"))
8337            .build();
8338
8339        let buy_fill2 = TestOrderEventStubs::filled(
8340            &buy_order2,
8341            &btc_usdt,
8342            Some(TradeId::new("3")),
8343            None,
8344            Some(Price::from("52000.0")),
8345            Some(Quantity::from("2.0")),
8346            None,
8347            Some(Money::new(0.002, btc_usdt.base_currency().unwrap())),
8348            None,
8349            None,
8350        );
8351
8352        position.apply(&buy_fill2.into());
8353
8354        // Verify adjustments were cleared and only new adjustment exists
8355        assert_eq!(
8356            position.adjustments.len(),
8357            1,
8358            "Adjustments should be cleared on position reset, only new adjustment"
8359        );
8360        assert_eq!(
8361            position.adjustments[0].quantity_change,
8362            Some(rust_decimal_macros::dec!(-0.002)),
8363            "New adjustment should be for the new fill"
8364        );
8365        assert_eq!(position.events.len(), 1, "Events should also be reset");
8366    }
8367
8368    #[rstest]
8369    fn test_id_accessors_deduplicate_and_sort(audusd_sim: CurrencyPair) {
8370        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
8371        let position_id = PositionId::from("P-IDS");
8372        let fill1 = OrderFilledSpec::builder()
8373            .instrument_id(instrument.id())
8374            .client_order_id(ClientOrderId::from("O-2"))
8375            .venue_order_id(VenueOrderId::from("V-2"))
8376            .trade_id(TradeId::from("T-3"))
8377            .order_side(OrderSide::Buy)
8378            .last_qty(Quantity::from(10))
8379            .last_px(Price::from("1.00000"))
8380            .currency(Currency::USD())
8381            .position_id(position_id)
8382            .ts_event(UnixNanos::from(1))
8383            .build();
8384        let fill2 = OrderFilledSpec::builder()
8385            .instrument_id(instrument.id())
8386            .client_order_id(ClientOrderId::from("O-1"))
8387            .venue_order_id(VenueOrderId::from("V-1"))
8388            .trade_id(TradeId::from("T-1"))
8389            .order_side(OrderSide::Buy)
8390            .last_qty(Quantity::from(10))
8391            .last_px(Price::from("1.00000"))
8392            .currency(Currency::USD())
8393            .position_id(position_id)
8394            .ts_event(UnixNanos::from(2))
8395            .build();
8396        let fill3 = OrderFilledSpec::builder()
8397            .instrument_id(instrument.id())
8398            .client_order_id(ClientOrderId::from("O-1"))
8399            .venue_order_id(VenueOrderId::from("V-1"))
8400            .trade_id(TradeId::from("T-2"))
8401            .order_side(OrderSide::Buy)
8402            .last_qty(Quantity::from(10))
8403            .last_px(Price::from("1.00000"))
8404            .currency(Currency::USD())
8405            .position_id(position_id)
8406            .ts_event(UnixNanos::from(3))
8407            .build();
8408        let mut position = Position::new(&instrument, fill1);
8409        position.apply(&fill2);
8410        position.apply(&fill3);
8411
8412        assert_eq!(
8413            position.client_order_ids(),
8414            vec![ClientOrderId::from("O-1"), ClientOrderId::from("O-2")]
8415        );
8416        assert_eq!(
8417            position.venue_order_ids(),
8418            vec![VenueOrderId::from("V-1"), VenueOrderId::from("V-2")]
8419        );
8420        assert_eq!(
8421            position.trade_ids(),
8422            vec![
8423                TradeId::from("T-1"),
8424                TradeId::from("T-2"),
8425                TradeId::from("T-3")
8426            ]
8427        );
8428    }
8429
8430    #[rstest]
8431    fn test_is_open_and_is_closed_require_both_conditions(audusd_sim: CurrencyPair) {
8432        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
8433        let position_id = PositionId::from("P-PREDICATES");
8434        let fill_open = OrderFilledSpec::builder()
8435            .instrument_id(instrument.id())
8436            .client_order_id(ClientOrderId::from("O-1"))
8437            .trade_id(TradeId::from("T-1"))
8438            .order_side(OrderSide::Buy)
8439            .last_qty(Quantity::from(10))
8440            .last_px(Price::from("1.00000"))
8441            .currency(Currency::USD())
8442            .position_id(position_id)
8443            .ts_event(UnixNanos::from(1))
8444            .build();
8445        let fill_close = OrderFilledSpec::builder()
8446            .instrument_id(instrument.id())
8447            .client_order_id(ClientOrderId::from("O-2"))
8448            .trade_id(TradeId::from("T-2"))
8449            .order_side(OrderSide::Sell)
8450            .last_qty(Quantity::from(10))
8451            .last_px(Price::from("1.00000"))
8452            .currency(Currency::USD())
8453            .position_id(position_id)
8454            .ts_event(UnixNanos::from(2))
8455            .build();
8456        let mut position = Position::new(&instrument, fill_open);
8457        position.apply(&fill_close);
8458
8459        assert!(position.is_closed());
8460        assert!(!position.is_open());
8461
8462        position
8463            .apply_adjustment(PositionAdjusted::new(
8464                position.trader_id,
8465                position.strategy_id,
8466                position.instrument_id,
8467                position.id,
8468                position.account_id,
8469                PositionAdjustmentType::Funding,
8470                Some(dec!(5)),
8471                None,
8472                None,
8473                uuid4(),
8474                UnixNanos::from(3),
8475                UnixNanos::from(3),
8476            ))
8477            .unwrap();
8478
8479        assert_eq!(position.side, PositionSide::Long);
8480        assert_eq!(position.ts_closed, Some(UnixNanos::from(2)));
8481        assert!(!position.is_open());
8482        assert!(!position.is_closed());
8483    }
8484
8485    #[rstest]
8486    fn test_voided_fill_rebate_leaves_no_residual_commission(audusd_sim: CurrencyPair) {
8487        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
8488        let position_id = PositionId::from("P-VOID-REBATE");
8489        let fill1 = OrderFilledSpec::builder()
8490            .instrument_id(instrument.id())
8491            .client_order_id(ClientOrderId::from("O-1"))
8492            .trade_id(TradeId::from("T-1"))
8493            .order_side(OrderSide::Buy)
8494            .last_qty(Quantity::from(10))
8495            .last_px(Price::from("1.00000"))
8496            .currency(Currency::USD())
8497            .position_id(position_id)
8498            .ts_event(UnixNanos::from(1))
8499            .build();
8500        let rebate = Money::from("-2.00 USD");
8501        let fill2 = OrderFilledSpec::builder()
8502            .instrument_id(instrument.id())
8503            .client_order_id(ClientOrderId::from("O-2"))
8504            .trade_id(TradeId::from("T-2"))
8505            .order_side(OrderSide::Buy)
8506            .last_qty(Quantity::from(10))
8507            .last_px(Price::from("1.00000"))
8508            .currency(Currency::USD())
8509            .commission(rebate)
8510            .position_id(position_id)
8511            .ts_event(UnixNanos::from(2))
8512            .build();
8513        let void2 = matching_fill_void(&fill2, Quantity::from(10), Some(rebate));
8514        let mut position = Position::new(&instrument, fill1);
8515        position.apply(&fill2);
8516
8517        position
8518            .apply_fill_void(void2, Quantity::from(10), Some(rebate))
8519            .unwrap();
8520
8521        assert_eq!(position.quantity, Quantity::from(10));
8522        assert!(position.commissions().is_empty());
8523        assert_eq!(position.realized_pnl, Some(Money::from("0.00 USD")));
8524    }
8525
8526    #[rstest]
8527    fn test_voided_fill_commission_accumulates_into_realized_pnl(audusd_sim: CurrencyPair) {
8528        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
8529        let position_id = PositionId::from("P-SURVIVING-QUOTE");
8530        let fill1 = OrderFilledSpec::builder()
8531            .instrument_id(instrument.id())
8532            .client_order_id(ClientOrderId::from("O-1"))
8533            .trade_id(TradeId::from("T-1"))
8534            .order_side(OrderSide::Buy)
8535            .last_qty(Quantity::from(10))
8536            .last_px(Price::from("1.00000"))
8537            .currency(Currency::USD())
8538            .commission(Money::from("2.00 USD"))
8539            .position_id(position_id)
8540            .ts_event(UnixNanos::from(1))
8541            .build();
8542        let fill2 = OrderFilledSpec::builder()
8543            .instrument_id(instrument.id())
8544            .client_order_id(ClientOrderId::from("O-2"))
8545            .trade_id(TradeId::from("T-2"))
8546            .order_side(OrderSide::Buy)
8547            .last_qty(Quantity::from(10))
8548            .last_px(Price::from("2.00000"))
8549            .currency(Currency::USD())
8550            .commission(Money::from("1.00 USD"))
8551            .position_id(position_id)
8552            .ts_event(UnixNanos::from(2))
8553            .build();
8554        let void2 = matching_fill_void(&fill2, Quantity::from(10), None);
8555        let mut position = Position::new(&instrument, fill1);
8556        position.apply(&fill2);
8557
8558        position
8559            .apply_fill_void(void2, Quantity::from(10), None)
8560            .unwrap();
8561
8562        assert_eq!(position.quantity, Quantity::from(10));
8563        assert_eq!(position.commissions(), vec![Money::from("3.00 USD")]);
8564        assert_eq!(position.realized_pnl, Some(Money::from("-3.00 USD")));
8565    }
8566
8567    #[rstest]
8568    fn test_voided_fill_base_commission_preserves_avg_px_open(audusd_sim: CurrencyPair) {
8569        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
8570        let base_currency = instrument.base_currency().unwrap();
8571        let position_id = PositionId::from("P-SURVIVING-BASE");
8572        let fill1 = OrderFilledSpec::builder()
8573            .instrument_id(instrument.id())
8574            .client_order_id(ClientOrderId::from("O-1"))
8575            .trade_id(TradeId::from("T-1"))
8576            .order_side(OrderSide::Buy)
8577            .last_qty(Quantity::from(10))
8578            .last_px(Price::from("1.00000"))
8579            .currency(Currency::USD())
8580            .commission(Money::new(2.0, base_currency))
8581            .position_id(position_id)
8582            .ts_event(UnixNanos::from(1))
8583            .build();
8584        let fill2 = OrderFilledSpec::builder()
8585            .instrument_id(instrument.id())
8586            .client_order_id(ClientOrderId::from("O-2"))
8587            .trade_id(TradeId::from("T-2"))
8588            .order_side(OrderSide::Buy)
8589            .last_qty(Quantity::from(10))
8590            .last_px(Price::from("2.00000"))
8591            .currency(Currency::USD())
8592            .commission(Money::new(1.0, base_currency))
8593            .position_id(position_id)
8594            .ts_event(UnixNanos::from(2))
8595            .build();
8596        let void2 = matching_fill_void(&fill2, Quantity::from(10), None);
8597        let mut position = Position::new(&instrument, fill1);
8598        position.apply(&fill2);
8599
8600        position
8601            .apply_fill_void(void2, Quantity::from(10), None)
8602            .unwrap();
8603
8604        assert_eq!(position.quantity, Quantity::from(7));
8605        assert_eq!(position.avg_px_open, dec!(1.0));
8606        assert_eq!(position.commissions(), vec![Money::new(3.0, base_currency)]);
8607    }
8608
8609    #[rstest]
8610    fn test_fill_fragments_requires_matching_order_and_trade(audusd_sim: CurrencyPair) {
8611        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
8612        let position_id = PositionId::from("P-FRAGMENTS");
8613        let fill1 = OrderFilledSpec::builder()
8614            .instrument_id(instrument.id())
8615            .client_order_id(ClientOrderId::from("O-1"))
8616            .trade_id(TradeId::from("T-1"))
8617            .order_side(OrderSide::Buy)
8618            .last_qty(Quantity::from(10))
8619            .last_px(Price::from("1.00000"))
8620            .currency(Currency::USD())
8621            .position_id(position_id)
8622            .ts_event(UnixNanos::from(1))
8623            .build();
8624        let fill2 = OrderFilledSpec::builder()
8625            .instrument_id(instrument.id())
8626            .client_order_id(ClientOrderId::from("O-1"))
8627            .trade_id(TradeId::from("T-2"))
8628            .order_side(OrderSide::Buy)
8629            .last_qty(Quantity::from(10))
8630            .last_px(Price::from("1.00000"))
8631            .currency(Currency::USD())
8632            .position_id(position_id)
8633            .ts_event(UnixNanos::from(2))
8634            .build();
8635        let mut position = Position::new(&instrument, fill1);
8636        position.apply(&fill2);
8637
8638        let fragments = position.fill_fragments(ClientOrderId::from("O-1"), TradeId::from("T-1"));
8639
8640        assert_eq!(fragments.len(), 1);
8641        assert_eq!(fragments[0].trade_id, TradeId::from("T-1"));
8642        assert!(
8643            position
8644                .fill_fragments(ClientOrderId::from("O-2"), TradeId::from("T-1"))
8645                .is_empty()
8646        );
8647    }
8648
8649    #[rstest]
8650    fn test_apply_fill_void_scopes_staleness_check_to_same_trade(audusd_sim: CurrencyPair) {
8651        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
8652        let position_id = PositionId::from("P-VOID-TRADES");
8653        let fill1 = OrderFilledSpec::builder()
8654            .instrument_id(instrument.id())
8655            .client_order_id(ClientOrderId::from("O-1"))
8656            .trade_id(TradeId::from("T-1"))
8657            .order_side(OrderSide::Buy)
8658            .last_qty(Quantity::from(10))
8659            .last_px(Price::from("1.00000"))
8660            .currency(Currency::USD())
8661            .position_id(position_id)
8662            .ts_event(UnixNanos::from(1))
8663            .build();
8664        let fill2 = OrderFilledSpec::builder()
8665            .instrument_id(instrument.id())
8666            .client_order_id(ClientOrderId::from("O-1"))
8667            .trade_id(TradeId::from("T-2"))
8668            .order_side(OrderSide::Buy)
8669            .last_qty(Quantity::from(10))
8670            .last_px(Price::from("1.00000"))
8671            .currency(Currency::USD())
8672            .position_id(position_id)
8673            .ts_event(UnixNanos::from(2))
8674            .build();
8675        let void1 = matching_fill_void(&fill1, Quantity::from(6), None);
8676        let void2 = matching_fill_void(&fill2, Quantity::from(2), None);
8677        let mut position = Position::new(&instrument, fill1);
8678        position.apply(&fill2);
8679        position
8680            .apply_fill_void(void1, Quantity::from(6), None)
8681            .unwrap();
8682
8683        position
8684            .apply_fill_void(void2, Quantity::from(2), None)
8685            .unwrap();
8686
8687        assert_eq!(position.quantity, Quantity::from(12));
8688        assert_eq!(position.fill_voids.len(), 2);
8689    }
8690
8691    #[rstest]
8692    fn test_apply_fill_void_removes_quantity_from_voided_trade_only(audusd_sim: CurrencyPair) {
8693        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
8694        let position_id = PositionId::from("P-VOID-ATTRIBUTION");
8695        let fill1 = OrderFilledSpec::builder()
8696            .instrument_id(instrument.id())
8697            .client_order_id(ClientOrderId::from("O-1"))
8698            .trade_id(TradeId::from("T-1"))
8699            .order_side(OrderSide::Buy)
8700            .last_qty(Quantity::from(10))
8701            .last_px(Price::from("1.00000"))
8702            .currency(Currency::USD())
8703            .position_id(position_id)
8704            .ts_event(UnixNanos::from(1))
8705            .build();
8706        let fill2 = OrderFilledSpec::builder()
8707            .instrument_id(instrument.id())
8708            .client_order_id(ClientOrderId::from("O-1"))
8709            .trade_id(TradeId::from("T-2"))
8710            .order_side(OrderSide::Buy)
8711            .last_qty(Quantity::from(10))
8712            .last_px(Price::from("2.00000"))
8713            .currency(Currency::USD())
8714            .position_id(position_id)
8715            .ts_event(UnixNanos::from(2))
8716            .build();
8717        let void1 = matching_fill_void(&fill1, Quantity::from(4), None);
8718        let mut position = Position::new(&instrument, fill1);
8719        position.apply(&fill2);
8720
8721        position
8722            .apply_fill_void(void1, Quantity::from(4), None)
8723            .unwrap();
8724
8725        assert_eq!(position.quantity, Quantity::from(16));
8726        assert_eq!(position.avg_px_open, dec!(1.625));
8727    }
8728
8729    #[rstest]
8730    fn test_purge_events_for_order_retains_other_order_fill_voids(audusd_sim: CurrencyPair) {
8731        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
8732        let position_id = PositionId::from("P-PURGE-VOID");
8733        let fill1 = OrderFilledSpec::builder()
8734            .instrument_id(instrument.id())
8735            .client_order_id(ClientOrderId::from("O-1"))
8736            .trade_id(TradeId::from("T-1"))
8737            .order_side(OrderSide::Buy)
8738            .last_qty(Quantity::from(10))
8739            .last_px(Price::from("1.00000"))
8740            .currency(Currency::USD())
8741            .position_id(position_id)
8742            .ts_event(UnixNanos::from(1))
8743            .build();
8744        let fill2 = OrderFilledSpec::builder()
8745            .instrument_id(instrument.id())
8746            .client_order_id(ClientOrderId::from("O-2"))
8747            .trade_id(TradeId::from("T-2"))
8748            .order_side(OrderSide::Buy)
8749            .last_qty(Quantity::from(10))
8750            .last_px(Price::from("1.00000"))
8751            .currency(Currency::USD())
8752            .position_id(position_id)
8753            .ts_event(UnixNanos::from(2))
8754            .build();
8755        let void1 = matching_fill_void(&fill1, Quantity::from(2), None);
8756        let void2 = matching_fill_void(&fill2, Quantity::from(3), None);
8757        let mut position = Position::new(&instrument, fill1);
8758        position.apply(&fill2);
8759        position
8760            .apply_fill_void(void1, Quantity::from(2), None)
8761            .unwrap();
8762        position
8763            .apply_fill_void(void2, Quantity::from(3), None)
8764            .unwrap();
8765
8766        assert_eq!(position.fill_voids.len(), 2);
8767
8768        position
8769            .purge_events_for_order(ClientOrderId::from("O-1"))
8770            .unwrap();
8771
8772        assert_eq!(position.fill_voids.len(), 1);
8773        assert_eq!(
8774            position.fill_voids[0].event.client_order_id,
8775            ClientOrderId::from("O-2")
8776        );
8777        assert_eq!(position.fill_voids[0].voided_qty, Quantity::from(3));
8778    }
8779
8780    #[rstest]
8781    fn test_purge_events_for_order_clears_adjustments_when_flat() {
8782        // Test that purging all fills clears adjustment history
8783        let btc_usdt = currency_pair_btcusdt();
8784        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
8785
8786        let order = OrderTestBuilder::new(OrderType::Market)
8787            .instrument_id(btc_usdt.id())
8788            .side(OrderSide::Buy)
8789            .quantity(Quantity::from("1.0"))
8790            .build();
8791
8792        let fill = TestOrderEventStubs::filled(
8793            &order,
8794            &btc_usdt,
8795            Some(TradeId::new("1")),
8796            None,
8797            Some(Price::from("50000.0")),
8798            Some(Quantity::from("1.0")),
8799            None,
8800            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
8801            None,
8802            None,
8803        );
8804
8805        let mut position = Position::new(&btc_usdt, fill.into());
8806        assert_eq!(position.adjustments.len(), 1, "Should have 1 adjustment");
8807        assert_eq!(position.events.len(), 1);
8808
8809        // Purge the only fill - should go to flat and clear everything
8810        position
8811            .purge_events_for_order(order.client_order_id())
8812            .unwrap();
8813
8814        assert_eq!(position.side, PositionSide::Flat);
8815        assert_eq!(position.events.len(), 0, "Events should be cleared");
8816        assert_eq!(
8817            position.adjustments.len(),
8818            0,
8819            "Adjustments should be cleared when position goes flat"
8820        );
8821        assert_eq!(position.quantity, Quantity::zero(btc_usdt.size_precision()));
8822    }
8823
8824    #[rstest]
8825    fn test_purge_events_for_order_clears_adjustments_on_rebuild() {
8826        // Test that rebuilding position from remaining fills clears and recreates adjustments
8827        let btc_usdt = currency_pair_btcusdt();
8828        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
8829
8830        // First fill with adjustment
8831        let order1 = OrderTestBuilder::new(OrderType::Market)
8832            .instrument_id(btc_usdt.id())
8833            .side(OrderSide::Buy)
8834            .quantity(Quantity::from("1.0"))
8835            .client_order_id(ClientOrderId::new("O-001"))
8836            .build();
8837
8838        let fill1 = TestOrderEventStubs::filled(
8839            &order1,
8840            &btc_usdt,
8841            Some(TradeId::new("1")),
8842            None,
8843            Some(Price::from("50000.0")),
8844            Some(Quantity::from("1.0")),
8845            None,
8846            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
8847            None,
8848            None,
8849        );
8850
8851        let mut position = Position::new(&btc_usdt, fill1.into());
8852        assert_eq!(position.adjustments.len(), 1);
8853
8854        // Second fill with different order and adjustment
8855        let order2 = OrderTestBuilder::new(OrderType::Market)
8856            .instrument_id(btc_usdt.id())
8857            .side(OrderSide::Buy)
8858            .quantity(Quantity::from("2.0"))
8859            .client_order_id(ClientOrderId::new("O-002"))
8860            .build();
8861
8862        let fill2 = TestOrderEventStubs::filled(
8863            &order2,
8864            &btc_usdt,
8865            Some(TradeId::new("2")),
8866            None,
8867            Some(Price::from("51000.0")),
8868            Some(Quantity::from("2.0")),
8869            None,
8870            Some(Money::new(0.002, btc_usdt.base_currency().unwrap())),
8871            None,
8872            None,
8873        );
8874
8875        position.apply(&fill2.into());
8876        assert_eq!(position.adjustments.len(), 2, "Should have 2 adjustments");
8877        assert_eq!(position.events.len(), 2);
8878
8879        // Purge first order - should rebuild from remaining fill
8880        position
8881            .purge_events_for_order(order1.client_order_id())
8882            .unwrap();
8883
8884        assert_eq!(position.events.len(), 1, "Should have 1 remaining event");
8885        assert_eq!(
8886            position.adjustments.len(),
8887            1,
8888            "Should have only the adjustment from remaining fill"
8889        );
8890        assert_eq!(
8891            position.adjustments[0].quantity_change,
8892            Some(rust_decimal_macros::dec!(-0.002)),
8893            "Should be the adjustment from order2"
8894        );
8895        assert!(
8896            (position.quantity.as_f64() - 1.998).abs() < 1e-9,
8897            "Quantity should be 2.0 - 0.002 commission"
8898        );
8899    }
8900
8901    fn btcusdt_fill(trade_id: &str, client_order_id: &str, quantity: &str) -> OrderFilled {
8902        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
8903        let order = OrderTestBuilder::new(OrderType::Market)
8904            .instrument_id(instrument.id())
8905            .side(OrderSide::Buy)
8906            .quantity(Quantity::from(quantity))
8907            .client_order_id(ClientOrderId::new(client_order_id))
8908            .build();
8909
8910        TestOrderEventStubs::filled(
8911            &order,
8912            &instrument,
8913            Some(TradeId::new(trade_id)),
8914            None,
8915            Some(Price::from("50000.0")),
8916            Some(Quantity::from(quantity)),
8917            None,
8918            Some(Money::new(1.0, instrument.quote_currency())),
8919            None,
8920            None,
8921        )
8922        .into()
8923    }
8924
8925    fn funding_payment(position: &Position, pnl: f64) -> PositionAdjusted {
8926        PositionAdjusted::new(
8927            position.trader_id,
8928            position.strategy_id,
8929            position.instrument_id,
8930            position.id,
8931            position.account_id,
8932            PositionAdjustmentType::Funding,
8933            None,
8934            Some(Money::new(pnl, position.settlement_currency)),
8935            None,
8936            uuid4(),
8937            UnixNanos::from(5),
8938            UnixNanos::from(5),
8939        )
8940    }
8941
8942    fn btcusdt_position() -> Position {
8943        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
8944        Position::new(&instrument, btcusdt_fill("1", "O-001", "1.0"))
8945    }
8946
8947    #[rstest]
8948    fn test_revert_last_adjustment_restores_prior_state() {
8949        let mut position = btcusdt_position();
8950        let before = serde_json::to_value(&position).unwrap();
8951        let prior = position.clone_without_events();
8952        position
8953            .apply_adjustment(funding_payment(&position, -10.0))
8954            .unwrap();
8955
8956        position.revert_last_adjustment(&prior).unwrap();
8957
8958        assert_eq!(serde_json::to_value(&position).unwrap(), before);
8959    }
8960
8961    fn assert_reverts_to_snapshot(mut position: Position, payment: PositionAdjusted) {
8962        let before = serde_json::to_value(&position).unwrap();
8963        let prior = position.clone_without_events();
8964        position.apply_adjustment(payment).unwrap();
8965
8966        position.revert_last_adjustment(&prior).unwrap();
8967
8968        assert_eq!(serde_json::to_value(&position).unwrap(), before);
8969    }
8970
8971    #[rstest]
8972    fn test_revert_last_adjustment_after_earlier_adjustment() {
8973        let mut position = btcusdt_position();
8974        position
8975            .apply_adjustment(funding_payment(&position, -10.0))
8976            .unwrap();
8977        let mut payment = funding_payment(&position, -5.0);
8978        payment.ts_event = UnixNanos::from(6);
8979
8980        assert_reverts_to_snapshot(position, payment);
8981    }
8982
8983    #[rstest]
8984    fn test_revert_last_adjustment_after_zero_value_adjustment_at_same_time() {
8985        let mut position = btcusdt_position();
8986        let prior = position.clone_without_events();
8987        let mut zero_payment = funding_payment(&position, 0.0);
8988        zero_payment.ts_event = position.ts_last;
8989        position.apply_adjustment(zero_payment).unwrap();
8990        let before = serde_json::to_value(&position).unwrap();
8991        position
8992            .apply_adjustment(funding_payment(&position, -5.0))
8993            .unwrap();
8994
8995        // The zero value payment at the snapshot's time leaves the snapshot's state unchanged
8996        position.revert_last_adjustment(&prior).unwrap();
8997
8998        assert_eq!(serde_json::to_value(&position).unwrap(), before);
8999    }
9000
9001    #[rstest]
9002    #[case::partial("0.2", None)]
9003    #[case::full("0.5", Some(1.0))]
9004    fn test_revert_last_adjustment_after_voided_fill(
9005        #[case] voided_qty: &str,
9006        #[case] commission_voided: Option<f64>,
9007    ) {
9008        let mut position = btcusdt_position();
9009        let mut fill = btcusdt_fill("2", "O-002", "0.5");
9010        fill.ts_event = UnixNanos::from(3);
9011        position.apply(&fill);
9012        let commission_voided =
9013            commission_voided.map(|amount| Money::new(amount, position.settlement_currency));
9014        position
9015            .apply_fill_void(
9016                matching_fill_void(&fill, Quantity::from(voided_qty), commission_voided),
9017                Quantity::from(voided_qty),
9018                commission_voided,
9019            )
9020            .unwrap();
9021        let payment = funding_payment(&position, -5.0);
9022
9023        assert_reverts_to_snapshot(position, payment);
9024    }
9025
9026    #[rstest]
9027    fn test_revert_last_adjustment_after_purge() {
9028        let mut position = btcusdt_position();
9029        let mut fill = btcusdt_fill("2", "O-002", "0.5");
9030        fill.ts_event = UnixNanos::from(3);
9031        position.apply(&fill);
9032        position
9033            .apply_adjustment(funding_payment(&position, -10.0))
9034            .unwrap();
9035        position
9036            .purge_events_for_order(ClientOrderId::new("O-002"))
9037            .unwrap();
9038        let mut payment = funding_payment(&position, -5.0);
9039        payment.ts_event = UnixNanos::from(6);
9040
9041        assert_reverts_to_snapshot(position, payment);
9042    }
9043
9044    #[rstest]
9045    fn test_revert_last_adjustment_after_reopening() {
9046        let mut position = btcusdt_position();
9047        let mut close = btcusdt_fill("2", "O-002", "1.0");
9048        close.order_side = OrderSide::Sell;
9049        close.ts_event = UnixNanos::from(2);
9050        position.apply(&close);
9051        let mut reopen = btcusdt_fill("3", "O-003", "0.5");
9052        reopen.ts_event = UnixNanos::from(3);
9053        position.apply(&reopen);
9054        let payment = funding_payment(&position, -5.0);
9055
9056        assert_reverts_to_snapshot(position, payment);
9057    }
9058
9059    #[rstest]
9060    fn test_revert_last_adjustment_rejects_snapshot_of_another_position() {
9061        let mut position = btcusdt_position();
9062        let mut prior = position.clone_without_events();
9063        prior.id = PositionId::new("P-OTHER");
9064        position
9065            .apply_adjustment(funding_payment(&position, -10.0))
9066            .unwrap();
9067        let after = serde_json::to_value(&position).unwrap();
9068
9069        let error = position.revert_last_adjustment(&prior).unwrap_err();
9070
9071        assert!(error.to_string().contains("prior.id"), "{error}");
9072        assert_eq!(serde_json::to_value(&position).unwrap(), after);
9073    }
9074
9075    #[rstest]
9076    fn test_revert_last_adjustment_rejects_after_later_fill() {
9077        let mut position = btcusdt_position();
9078        let prior = position.clone_without_events();
9079        position
9080            .apply_adjustment(funding_payment(&position, -10.0))
9081            .unwrap();
9082        position.apply(&btcusdt_fill("2", "O-002", "0.5"));
9083        let after = serde_json::to_value(&position).unwrap();
9084
9085        let error = position.revert_last_adjustment(&prior).unwrap_err();
9086
9087        assert!(
9088            error.to_string().contains("not its latest adjustment"),
9089            "{error}"
9090        );
9091        assert_eq!(serde_json::to_value(&position).unwrap(), after);
9092    }
9093
9094    #[rstest]
9095    fn test_revert_last_adjustment_rejects_stale_snapshot() {
9096        let mut position = btcusdt_position();
9097        let prior = position.clone_without_events();
9098        position
9099            .apply_adjustment(funding_payment(&position, -10.0))
9100            .unwrap();
9101        position
9102            .apply_adjustment(funding_payment(&position, -5.0))
9103            .unwrap();
9104        let after = serde_json::to_value(&position).unwrap();
9105
9106        let error = position.revert_last_adjustment(&prior).unwrap_err();
9107
9108        assert!(error.to_string().contains("predates adjustment"), "{error}");
9109        assert_eq!(serde_json::to_value(&position).unwrap(), after);
9110    }
9111
9112    #[rstest]
9113    fn test_revert_last_adjustment_rejects_snapshot_before_zero_value_adjustment() {
9114        let mut position = btcusdt_position();
9115        let prior = position.clone_without_events();
9116        position
9117            .apply_adjustment(funding_payment(&position, 0.0))
9118            .unwrap();
9119        let mut later_payment = funding_payment(&position, -5.0);
9120        later_payment.ts_event = UnixNanos::from(6);
9121        later_payment.ts_init = UnixNanos::from(6);
9122        position.apply_adjustment(later_payment).unwrap();
9123        let after = serde_json::to_value(&position).unwrap();
9124
9125        let error = position.revert_last_adjustment(&prior).unwrap_err();
9126
9127        assert!(error.to_string().contains("predates adjustment"), "{error}");
9128        assert_eq!(serde_json::to_value(&position).unwrap(), after);
9129    }
9130
9131    #[rstest]
9132    fn test_revert_last_adjustment_rejects_snapshot_before_zero_value_adjustment_and_voided_fill() {
9133        let mut position = btcusdt_position();
9134        let prior = position.clone_without_events();
9135        position
9136            .apply_adjustment(funding_payment(&position, 0.0))
9137            .unwrap();
9138        let mut fill = btcusdt_fill("2", "O-002", "0.5");
9139        fill.ts_event = UnixNanos::from(6);
9140        position.apply(&fill);
9141        let commission = Money::new(1.0, position.settlement_currency);
9142        position
9143            .apply_fill_void(
9144                matching_fill_void(&fill, Quantity::from("0.5"), Some(commission)),
9145                Quantity::from("0.5"),
9146                Some(commission),
9147            )
9148            .unwrap();
9149        let mut later_payment = funding_payment(&position, -5.0);
9150        later_payment.ts_event = UnixNanos::from(7);
9151        position.apply_adjustment(later_payment).unwrap();
9152        let after = serde_json::to_value(&position).unwrap();
9153
9154        let error = position.revert_last_adjustment(&prior).unwrap_err();
9155
9156        assert!(error.to_string().contains("predates adjustment"), "{error}");
9157        assert_eq!(serde_json::to_value(&position).unwrap(), after);
9158    }
9159
9160    #[rstest]
9161    fn test_revert_last_adjustment_rejects_snapshot_with_pnl_at_money_bounds() {
9162        let mut position = btcusdt_position();
9163        let mut prior = position.clone_without_events();
9164        prior.realized_pnl = Some(Money::from_raw(MONEY_RAW_MAX, position.settlement_currency));
9165        position
9166            .apply_adjustment(funding_payment(&position, 10.0))
9167            .unwrap();
9168        let after = serde_json::to_value(&position).unwrap();
9169
9170        let error = position.revert_last_adjustment(&prior).unwrap_err();
9171
9172        assert!(
9173            error.to_string().contains("cannot take the PnL change"),
9174            "{error}"
9175        );
9176        assert_eq!(serde_json::to_value(&position).unwrap(), after);
9177    }
9178
9179    #[rstest]
9180    #[case::size_precision("prior.size_precision")]
9181    #[case::settlement_currency("prior.settlement_currency")]
9182    fn test_revert_last_adjustment_rejects_snapshot_of_other_instrument_config(
9183        #[case] field: &str,
9184    ) {
9185        let mut position = btcusdt_position();
9186        let mut prior = position.clone_without_events();
9187        match field {
9188            "prior.size_precision" => prior.size_precision += 1,
9189            _ => prior.settlement_currency = Currency::USD(),
9190        }
9191
9192        position
9193            .apply_adjustment(funding_payment(&position, -10.0))
9194            .unwrap();
9195        let after = serde_json::to_value(&position).unwrap();
9196
9197        let error = position.revert_last_adjustment(&prior).unwrap_err();
9198
9199        assert!(error.to_string().contains(field), "{error}");
9200        assert_eq!(serde_json::to_value(&position).unwrap(), after);
9201    }
9202
9203    #[rstest]
9204    fn test_revert_last_adjustment_rejects_snapshot_with_other_pnl_currency() {
9205        let mut position = btcusdt_position();
9206        let mut prior = position.clone_without_events();
9207        prior.realized_pnl = Some(Money::new(1.0, Currency::USD()));
9208        position
9209            .apply_adjustment(funding_payment(&position, -10.0))
9210            .unwrap();
9211        let after = serde_json::to_value(&position).unwrap();
9212
9213        let error = position.revert_last_adjustment(&prior).unwrap_err();
9214
9215        assert!(
9216            error.to_string().contains("cannot take the PnL change"),
9217            "{error}"
9218        );
9219        assert_eq!(serde_json::to_value(&position).unwrap(), after);
9220    }
9221
9222    #[rstest]
9223    fn test_purge_events_preserves_manual_adjustments() {
9224        // Test that manual adjustments (e.g., funding payments) are preserved when purging unrelated fills
9225        let btc_usdt = currency_pair_btcusdt();
9226        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
9227
9228        // First fill
9229        let order1 = OrderTestBuilder::new(OrderType::Market)
9230            .instrument_id(btc_usdt.id())
9231            .side(OrderSide::Buy)
9232            .quantity(Quantity::from("1.0"))
9233            .client_order_id(ClientOrderId::new("O-001"))
9234            .build();
9235
9236        let fill1 = TestOrderEventStubs::filled(
9237            &order1,
9238            &btc_usdt,
9239            Some(TradeId::new("1")),
9240            None,
9241            Some(Price::from("50000.0")),
9242            Some(Quantity::from("1.0")),
9243            None,
9244            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
9245            None,
9246            None,
9247        );
9248
9249        let mut position = Position::new(&btc_usdt, fill1.into());
9250        assert_eq!(position.adjustments.len(), 1);
9251
9252        // Apply a manual funding payment adjustment (no reason field)
9253        let funding_adjustment = PositionAdjusted::new(
9254            position.trader_id,
9255            position.strategy_id,
9256            position.instrument_id,
9257            position.id,
9258            position.account_id,
9259            PositionAdjustmentType::Funding,
9260            None,
9261            Some(Money::new(10.0, btc_usdt.quote_currency())),
9262            None, // No reason - this is a manual adjustment
9263            uuid4(),
9264            UnixNanos::default(),
9265            UnixNanos::default(),
9266        );
9267        position.apply_adjustment(funding_adjustment).unwrap();
9268        assert_eq!(position.adjustments.len(), 2);
9269
9270        // Second fill with different order
9271        let order2 = OrderTestBuilder::new(OrderType::Market)
9272            .instrument_id(btc_usdt.id())
9273            .side(OrderSide::Buy)
9274            .quantity(Quantity::from("2.0"))
9275            .client_order_id(ClientOrderId::new("O-002"))
9276            .build();
9277
9278        let fill2 = TestOrderEventStubs::filled(
9279            &order2,
9280            &btc_usdt,
9281            Some(TradeId::new("2")),
9282            None,
9283            Some(Price::from("51000.0")),
9284            Some(Quantity::from("2.0")),
9285            None,
9286            Some(Money::new(0.002, btc_usdt.base_currency().unwrap())),
9287            None,
9288            None,
9289        );
9290
9291        position.apply(&fill2.into());
9292        assert_eq!(
9293            position.adjustments.len(),
9294            3,
9295            "Should have 3 adjustments: 2 commissions + 1 funding"
9296        );
9297
9298        // Purge first order - manual funding adjustment should be preserved
9299        position
9300            .purge_events_for_order(order1.client_order_id())
9301            .unwrap();
9302
9303        assert_eq!(position.events.len(), 1, "Should have 1 remaining event");
9304        assert_eq!(
9305            position.adjustments.len(),
9306            2,
9307            "Should have funding adjustment + commission from remaining fill"
9308        );
9309
9310        // Verify funding adjustment is preserved
9311        let has_funding = position.adjustments.iter().any(|adj| {
9312            adj.adjustment_type == PositionAdjustmentType::Funding
9313                && adj.pnl_change == Some(Money::new(10.0, btc_usdt.quote_currency()))
9314        });
9315        assert!(has_funding, "Funding adjustment should be preserved");
9316
9317        // Verify realized_pnl includes the funding payment
9318        // Note: Commission is in BTC (base currency), so it doesn't directly affect USDT realized_pnl
9319        assert_eq!(
9320            position.realized_pnl,
9321            Some(Money::new(10.0, btc_usdt.quote_currency())),
9322            "Realized PnL should be the funding payment only (commission is in BTC, not USDT)"
9323        );
9324    }
9325
9326    #[rstest]
9327    fn test_position_commission_affects_buy_and_sell_qty() {
9328        // Test that commission in base currency affects both buy_qty and sell_qty tracking
9329        let btc_usdt = currency_pair_btcusdt();
9330        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
9331
9332        let buy_order = OrderTestBuilder::new(OrderType::Market)
9333            .instrument_id(btc_usdt.id())
9334            .side(OrderSide::Buy)
9335            .quantity(Quantity::from("1.0"))
9336            .build();
9337
9338        // Buy 1.0 BTC with 0.001 BTC commission
9339        let fill = TestOrderEventStubs::filled(
9340            &buy_order,
9341            &btc_usdt,
9342            Some(TradeId::new("1")),
9343            None,
9344            Some(Price::from("50000.0")),
9345            Some(Quantity::from("1.0")),
9346            None,
9347            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
9348            None,
9349            None,
9350        );
9351
9352        let position = Position::new(&btc_usdt, fill.into());
9353
9354        // buy_qty tracks order fills (1.0 BTC), adjustments tracked separately
9355        assert!(
9356            (position.buy_qty.as_f64() - 1.0).abs() < 1e-9,
9357            "buy_qty should be 1.0 (order fill amount), was {}",
9358            position.buy_qty.as_f64()
9359        );
9360
9361        // Position quantity reflects both order fill and commission adjustment
9362        assert!(
9363            (position.quantity.as_f64() - 0.999).abs() < 1e-9,
9364            "position.quantity should be 0.999 (1.0 - 0.001 commission), was {}",
9365            position.quantity.as_f64()
9366        );
9367
9368        // Adjustment event tracks the commission
9369        assert_eq!(position.adjustments.len(), 1);
9370        assert_eq!(
9371            position.adjustments[0].quantity_change,
9372            Some(rust_decimal_macros::dec!(-0.001))
9373        );
9374    }
9375
9376    #[rstest]
9377    fn test_position_perpetual_commission_no_adjustment() {
9378        // Test that perpetuals/futures do NOT adjust quantity for base currency commission
9379        let eth_perp = crypto_perpetual_ethusdt();
9380        let eth_perp = InstrumentAny::CryptoPerpetual(eth_perp);
9381
9382        let order = OrderTestBuilder::new(OrderType::Market)
9383            .instrument_id(eth_perp.id())
9384            .side(OrderSide::Buy)
9385            .quantity(Quantity::from("1.0"))
9386            .build();
9387
9388        // Buy 1.0 ETH-PERP contracts with 0.001 ETH commission
9389        let fill = TestOrderEventStubs::filled(
9390            &order,
9391            &eth_perp,
9392            Some(TradeId::new("1")),
9393            None,
9394            Some(Price::from("3000.0")),
9395            Some(Quantity::from("1.0")),
9396            None,
9397            Some(Money::new(0.001, eth_perp.base_currency().unwrap())),
9398            None,
9399            None,
9400        );
9401
9402        let position = Position::new(&eth_perp, fill.into());
9403
9404        // Position quantity should be exactly 1.0 (NO adjustment for derivatives)
9405        assert!(
9406            (position.quantity.as_f64() - 1.0).abs() < 1e-9,
9407            "Perpetual position should be 1.0 contracts (no adjustment), was {}",
9408            position.quantity.as_f64()
9409        );
9410
9411        // Signed qty should also be 1.0
9412        assert!(
9413            (position.signed_qty - dec!(1.0)).abs() < dec!(1e-9),
9414            "Signed qty should be 1.0, was {}",
9415            position.signed_qty
9416        );
9417    }
9418
9419    #[rstest]
9420    fn test_signed_decimal_qty_long(stub_position_long: Position) {
9421        let signed_qty = stub_position_long.signed_decimal_qty();
9422        assert!(signed_qty > Decimal::ZERO);
9423        assert_eq!(signed_qty, stub_position_long.signed_qty);
9424    }
9425
9426    #[rstest]
9427    fn test_signed_decimal_qty_short(stub_position_short: Position) {
9428        let signed_qty = stub_position_short.signed_decimal_qty();
9429        assert!(signed_qty < Decimal::ZERO);
9430        assert_eq!(signed_qty, stub_position_short.signed_qty);
9431    }
9432
9433    #[rstest]
9434    fn test_signed_decimal_qty_flat(audusd_sim: CurrencyPair) {
9435        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
9436        let order = OrderTestBuilder::new(OrderType::Market)
9437            .instrument_id(audusd_sim.id())
9438            .side(OrderSide::Buy)
9439            .quantity(Quantity::from(100_000))
9440            .build();
9441        let fill = TestOrderEventStubs::filled(
9442            &order,
9443            &audusd_sim,
9444            Some(TradeId::new("1")),
9445            None,
9446            Some(Price::from("1.00001")),
9447            None,
9448            None,
9449            None,
9450            None,
9451            None,
9452        );
9453        let mut position = Position::new(&audusd_sim, fill.into());
9454
9455        let close_order = OrderTestBuilder::new(OrderType::Market)
9456            .instrument_id(audusd_sim.id())
9457            .side(OrderSide::Sell)
9458            .quantity(Quantity::from(100_000))
9459            .build();
9460        let close_fill = TestOrderEventStubs::filled(
9461            &close_order,
9462            &audusd_sim,
9463            Some(TradeId::new("2")),
9464            None,
9465            Some(Price::from("1.00002")),
9466            None,
9467            None,
9468            None,
9469            None,
9470            None,
9471        );
9472        position.apply(&close_fill.into());
9473
9474        assert_eq!(position.side, PositionSide::Flat);
9475        assert_eq!(position.signed_decimal_qty(), Decimal::ZERO);
9476    }
9477
9478    #[rstest]
9479    fn test_position_flat_with_floating_point_precision_edge_case() {
9480        // This test verifies that when signed_qty has accumulated floating-point
9481        // errors (tiny non-zero value) but quantity rounds to zero, the position
9482        // correctly becomes FLAT with signed_qty normalized to 0.0
9483        let btc_usdt = currency_pair_btcusdt();
9484        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
9485
9486        let order1 = OrderTestBuilder::new(OrderType::Market)
9487            .instrument_id(btc_usdt.id())
9488            .side(OrderSide::Buy)
9489            .quantity(Quantity::from("0.123456789"))
9490            .build();
9491        let fill1 = TestOrderEventStubs::filled(
9492            &order1,
9493            &btc_usdt,
9494            Some(TradeId::new("1")),
9495            None,
9496            Some(Price::from("50000.00")),
9497            None,
9498            None,
9499            None,
9500            None,
9501            None,
9502        );
9503        let mut position = Position::new(&btc_usdt, fill1.into());
9504
9505        assert_eq!(position.side, PositionSide::Long);
9506        assert!(position.quantity.is_positive());
9507
9508        let order2 = OrderTestBuilder::new(OrderType::Market)
9509            .instrument_id(btc_usdt.id())
9510            .side(OrderSide::Sell)
9511            .quantity(Quantity::from("0.123456789"))
9512            .build();
9513        let fill2 = TestOrderEventStubs::filled(
9514            &order2,
9515            &btc_usdt,
9516            Some(TradeId::new("2")),
9517            None,
9518            Some(Price::from("50000.00")),
9519            None,
9520            None,
9521            None,
9522            None,
9523            None,
9524        );
9525        position.apply(&fill2.into());
9526
9527        assert_eq!(
9528            position.side,
9529            PositionSide::Flat,
9530            "Position should be FLAT, not {:?}",
9531            position.side
9532        );
9533        assert!(
9534            position.quantity.is_zero(),
9535            "Quantity should be zero, was {}",
9536            position.quantity
9537        );
9538        assert_eq!(
9539            position.signed_qty,
9540            dec!(0.0),
9541            "signed_qty should be normalized to 0.0, was {}",
9542            position.signed_qty
9543        );
9544        assert!(position.is_closed());
9545    }
9546
9547    #[rstest]
9548    #[case(OrderSide::Buy, OrderSide::Sell, "162.50", "176.50", 171.5)]
9549    #[case(OrderSide::Sell, OrderSide::Buy, "140.00", "126.00", 131.0)]
9550    fn test_position_exact_close_after_partial_fills_preserves_open_average(
9551        #[case] entry: OrderSide,
9552        #[case] exit: OrderSide,
9553        #[case] first_close_px: &str,
9554        #[case] final_close_px: &str,
9555        #[case] expected_avg_close: f64,
9556    ) {
9557        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
9558        let position_id = PositionId::new("P-PARTIAL-CLOSE");
9559        let open_order = OrderTestBuilder::new(OrderType::Market)
9560            .instrument_id(instrument.id())
9561            .client_order_id(ClientOrderId::new("O-OPEN"))
9562            .side(entry)
9563            .quantity(Quantity::from("0.7"))
9564            .build();
9565        let open_fill = TestOrderEventStubs::filled(
9566            &open_order,
9567            &instrument,
9568            Some(TradeId::new("T-OPEN")),
9569            Some(position_id),
9570            Some(Price::from("151.25")),
9571            None,
9572            None,
9573            Some(Money::from("0 USDT")),
9574            Some(UnixNanos::from(1_000)),
9575            None,
9576        );
9577        let mut position = Position::new(&instrument, open_fill.into());
9578
9579        for (client_order_id, trade_id, quantity, price, ts_event) in [
9580            ("O-CLOSE-1", "T-CLOSE-1", "0.25", first_close_px, 1_100),
9581            ("O-CLOSE-2", "T-CLOSE-2", "0.45", final_close_px, 1_250),
9582        ] {
9583            let close_order = OrderTestBuilder::new(OrderType::Market)
9584                .instrument_id(instrument.id())
9585                .client_order_id(ClientOrderId::new(client_order_id))
9586                .side(exit)
9587                .quantity(Quantity::from(quantity))
9588                .build();
9589            let close_fill = TestOrderEventStubs::filled(
9590                &close_order,
9591                &instrument,
9592                Some(TradeId::new(trade_id)),
9593                Some(position_id),
9594                Some(Price::from(price)),
9595                None,
9596                None,
9597                Some(Money::from("0 USDT")),
9598                Some(UnixNanos::from(ts_event)),
9599                None,
9600            );
9601            position.apply(&close_fill.into());
9602        }
9603
9604        assert_eq!(position.entry, entry);
9605        assert_eq!(position.side, PositionSide::Flat);
9606        assert_eq!(position.signed_qty, dec!(0.0));
9607        assert_eq!(position.quantity, Quantity::zero(6));
9608        assert_eq!(position.peak_qty, Quantity::from("0.7"));
9609        assert_eq!(position.buy_qty, Quantity::from("0.7"));
9610        assert_eq!(position.sell_qty, Quantity::from("0.7"));
9611        assert_eq!(position.avg_px_open, dec!(151.25));
9612        assert_eq!(
9613            position.avg_px_close,
9614            Some(Decimal::try_from(expected_avg_close).unwrap())
9615        );
9616        assert_eq!(position.realized_return, 0.133_884_297_520_661_17);
9617        assert_eq!(position.realized_pnl, Some(Money::from("14.17500000 USDT")));
9618        assert_eq!(position.commissions(), vec![Money::from("0 USDT")]);
9619        assert_eq!(position.opening_order_id, ClientOrderId::new("O-OPEN"));
9620        assert_eq!(
9621            position.closing_order_id,
9622            Some(ClientOrderId::new("O-CLOSE-2"))
9623        );
9624        assert_eq!(position.ts_opened, UnixNanos::from(1_000));
9625        assert_eq!(position.ts_last, UnixNanos::from(1_250));
9626        assert_eq!(position.ts_closed, Some(UnixNanos::from(1_250)));
9627        assert_eq!(position.duration_ns, DurationNanos::new(250));
9628        assert_eq!(position.event_count(), 3);
9629        assert!(position.is_closed());
9630    }
9631
9632    #[rstest]
9633    #[case(
9634        OrderSide::Buy,
9635        OrderSide::Sell,
9636        "140.00",
9637        "126.00",
9638        PositionSide::Short,
9639        -0.000_001
9640    )]
9641    #[case(
9642        OrderSide::Sell,
9643        OrderSide::Buy,
9644        "162.50",
9645        "176.50",
9646        PositionSide::Long,
9647        0.000_001
9648    )]
9649    fn test_position_true_reversal_uses_fill_price(
9650        #[case] entry: OrderSide,
9651        #[case] exit: OrderSide,
9652        #[case] first_close_px: &str,
9653        #[case] reversal_px: &str,
9654        #[case] expected_side: PositionSide,
9655        #[case] expected_signed_qty: f64,
9656    ) {
9657        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
9658        let position_id = PositionId::new("P-REVERSAL");
9659        let open_order = OrderTestBuilder::new(OrderType::Market)
9660            .instrument_id(instrument.id())
9661            .client_order_id(ClientOrderId::new("O-REVERSAL-OPEN"))
9662            .side(entry)
9663            .quantity(Quantity::from("0.7"))
9664            .build();
9665        let open_fill = TestOrderEventStubs::filled(
9666            &open_order,
9667            &instrument,
9668            Some(TradeId::new("T-REVERSAL-OPEN")),
9669            Some(position_id),
9670            Some(Price::from("151.25")),
9671            None,
9672            None,
9673            Some(Money::from("0 USDT")),
9674            Some(UnixNanos::from(2_000)),
9675            None,
9676        );
9677        let mut position = Position::new(&instrument, open_fill.into());
9678
9679        let close_order = OrderTestBuilder::new(OrderType::Market)
9680            .instrument_id(instrument.id())
9681            .client_order_id(ClientOrderId::new("O-REVERSAL-CLOSE"))
9682            .side(exit)
9683            .quantity(Quantity::from("0.25"))
9684            .build();
9685        let close_fill = TestOrderEventStubs::filled(
9686            &close_order,
9687            &instrument,
9688            Some(TradeId::new("T-REVERSAL-CLOSE")),
9689            Some(position_id),
9690            Some(Price::from(first_close_px)),
9691            None,
9692            None,
9693            Some(Money::from("0 USDT")),
9694            Some(UnixNanos::from(2_050)),
9695            None,
9696        );
9697        position.apply(&close_fill.into());
9698
9699        let reversal_order = OrderTestBuilder::new(OrderType::Market)
9700            .instrument_id(instrument.id())
9701            .client_order_id(ClientOrderId::new("O-REVERSAL"))
9702            .side(exit)
9703            .quantity(Quantity::from("0.450001"))
9704            .build();
9705        let reversal_fill = TestOrderEventStubs::filled(
9706            &reversal_order,
9707            &instrument,
9708            Some(TradeId::new("T-REVERSAL")),
9709            Some(position_id),
9710            Some(Price::from(reversal_px)),
9711            None,
9712            None,
9713            Some(Money::from("0 USDT")),
9714            Some(UnixNanos::from(2_100)),
9715            None,
9716        );
9717        position.apply(&reversal_fill.into());
9718
9719        assert_eq!(position.entry, exit);
9720        assert_eq!(position.side, expected_side);
9721        assert_eq!(
9722            position.signed_qty,
9723            Decimal::try_from(expected_signed_qty).unwrap()
9724        );
9725        assert_eq!(position.quantity, Quantity::from("0.000001"));
9726        assert_eq!(position.peak_qty, Quantity::from("0.7"));
9727        assert_eq!(position.avg_px_open, Price::from(reversal_px).as_decimal());
9728        assert_eq!(
9729            position.realized_pnl,
9730            Some(Money::from("-14.17500000 USDT"))
9731        );
9732        assert_eq!(position.commissions(), vec![Money::from("0 USDT")]);
9733        assert_eq!(
9734            position.opening_order_id,
9735            ClientOrderId::new("O-REVERSAL-OPEN")
9736        );
9737        assert_eq!(position.closing_order_id, None);
9738        assert_eq!(position.ts_opened, UnixNanos::from(2_000));
9739        assert_eq!(position.ts_last, UnixNanos::from(2_100));
9740        assert_eq!(position.ts_closed, None);
9741        assert_eq!(position.duration_ns, DurationNanos::default());
9742        assert_eq!(position.event_count(), 3);
9743        assert!(position.is_open());
9744    }
9745
9746    #[rstest]
9747    #[case(OrderSide::Buy, OrderSide::Sell)]
9748    #[case(OrderSide::Sell, OrderSide::Buy)]
9749    fn test_position_reversal_starts_new_close_episode(
9750        #[case] entry: OrderSide,
9751        #[case] exit: OrderSide,
9752    ) {
9753        let (
9754            open_px,
9755            first_close_px,
9756            reversal_px,
9757            expected_side,
9758            new_first_close_px,
9759            new_final_close_px,
9760            expected_avg_close,
9761            expected_return,
9762        ) = if entry == OrderSide::Buy {
9763            (
9764                "100.00",
9765                "110.00",
9766                "120.00",
9767                PositionSide::Short,
9768                "110.00",
9769                "90.00",
9770                95.0,
9771                0.208_333_333_333_333_34,
9772            )
9773        } else {
9774            (
9775                "120.00",
9776                "110.00",
9777                "100.00",
9778                PositionSide::Long,
9779                "110.00",
9780                "130.00",
9781                125.0,
9782                0.25,
9783            )
9784        };
9785        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
9786        let position_id = PositionId::new("P-REVERSAL-EPISODE");
9787        let open_order = OrderTestBuilder::new(OrderType::Market)
9788            .instrument_id(instrument.id())
9789            .client_order_id(ClientOrderId::new("O-OPEN"))
9790            .side(entry)
9791            .quantity(Quantity::from("10"))
9792            .build();
9793        let open_fill = TestOrderEventStubs::filled(
9794            &open_order,
9795            &instrument,
9796            Some(TradeId::new("T-OPEN")),
9797            Some(position_id),
9798            Some(Price::from(open_px)),
9799            None,
9800            None,
9801            Some(Money::from("1 USDT")),
9802            Some(UnixNanos::from(3_000)),
9803            None,
9804        );
9805        let mut position = Position::new(&instrument, open_fill.into());
9806
9807        for (client_order_id, trade_id, quantity, price, ts_event) in [
9808            ("O-CLOSE", "T-CLOSE", "4", first_close_px, 3_100),
9809            ("O-REVERSE", "T-REVERSE", "8", reversal_px, 3_200),
9810        ] {
9811            let order = OrderTestBuilder::new(OrderType::Market)
9812                .instrument_id(instrument.id())
9813                .client_order_id(ClientOrderId::new(client_order_id))
9814                .side(exit)
9815                .quantity(Quantity::from(quantity))
9816                .build();
9817            let fill = TestOrderEventStubs::filled(
9818                &order,
9819                &instrument,
9820                Some(TradeId::new(trade_id)),
9821                Some(position_id),
9822                Some(Price::from(price)),
9823                None,
9824                None,
9825                Some(Money::from("1 USDT")),
9826                Some(UnixNanos::from(ts_event)),
9827                None,
9828            );
9829            position.apply(&fill.into());
9830        }
9831
9832        assert_eq!(position.side, expected_side);
9833        assert_eq!(position.quantity, Quantity::from("2"));
9834        assert_eq!(position.avg_px_open, Price::from(reversal_px).as_decimal());
9835        assert_eq!(position.avg_px_close, None);
9836        assert_eq!(position.realized_return, 0.0);
9837        if expected_side == PositionSide::Long {
9838            assert_eq!(position.buy_qty, Quantity::from("2"));
9839            assert_eq!(position.sell_qty, Quantity::from("0"));
9840        } else {
9841            assert_eq!(position.buy_qty, Quantity::from("0"));
9842            assert_eq!(position.sell_qty, Quantity::from("2"));
9843        }
9844        assert_eq!(position.realized_pnl, Some(Money::from("157 USDT")));
9845
9846        for (client_order_id, trade_id, quantity, price, ts_event) in [
9847            (
9848                "O-NEW-CLOSE-1",
9849                "T-NEW-CLOSE-1",
9850                "0.5",
9851                new_first_close_px,
9852                3_300,
9853            ),
9854            (
9855                "O-NEW-CLOSE-2",
9856                "T-NEW-CLOSE-2",
9857                "1.5",
9858                new_final_close_px,
9859                3_400,
9860            ),
9861        ] {
9862            let order = OrderTestBuilder::new(OrderType::Market)
9863                .instrument_id(instrument.id())
9864                .client_order_id(ClientOrderId::new(client_order_id))
9865                .side(entry)
9866                .quantity(Quantity::from(quantity))
9867                .build();
9868            let fill = TestOrderEventStubs::filled(
9869                &order,
9870                &instrument,
9871                Some(TradeId::new(trade_id)),
9872                Some(position_id),
9873                Some(Price::from(price)),
9874                None,
9875                None,
9876                Some(Money::from("1 USDT")),
9877                Some(UnixNanos::from(ts_event)),
9878                None,
9879            );
9880            position.apply(&fill.into());
9881        }
9882
9883        assert_eq!(position.side, PositionSide::Flat);
9884        assert_eq!(position.quantity, Quantity::zero(6));
9885        assert_eq!(position.buy_qty, Quantity::from("2"));
9886        assert_eq!(position.sell_qty, Quantity::from("2"));
9887        assert_eq!(
9888            position.avg_px_close,
9889            Some(Decimal::try_from(expected_avg_close).unwrap())
9890        );
9891        assert_eq!(position.realized_return, expected_return);
9892        assert_eq!(position.realized_pnl, Some(Money::from("205 USDT")));
9893        assert_eq!(position.commissions(), vec![Money::from("5 USDT")]);
9894    }
9895
9896    #[rstest]
9897    fn test_position_adjustment_floating_point_precision_edge_case() {
9898        // Test that apply_adjustment handles precision edge cases correctly
9899        let btc_usdt = currency_pair_btcusdt();
9900        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
9901
9902        let order = OrderTestBuilder::new(OrderType::Market)
9903            .instrument_id(btc_usdt.id())
9904            .side(OrderSide::Buy)
9905            .quantity(Quantity::from("1.0"))
9906            .build();
9907        let fill = TestOrderEventStubs::filled(
9908            &order,
9909            &btc_usdt,
9910            Some(TradeId::new("1")),
9911            None,
9912            Some(Price::from("50000.00")),
9913            None,
9914            None,
9915            None,
9916            None,
9917            None,
9918        );
9919        let mut position = Position::new(&btc_usdt, fill.into());
9920
9921        let adjustment = PositionAdjusted::new(
9922            position.trader_id,
9923            position.strategy_id,
9924            position.instrument_id,
9925            position.id,
9926            position.account_id,
9927            PositionAdjustmentType::Commission,
9928            Some(Decimal::from_str("-1.0").unwrap()),
9929            None,
9930            None,
9931            uuid4(),
9932            UnixNanos::default(),
9933            UnixNanos::default(),
9934        );
9935        position.apply_adjustment(adjustment).unwrap();
9936
9937        assert_eq!(
9938            position.side,
9939            PositionSide::Flat,
9940            "Position should be FLAT after zeroing adjustment"
9941        );
9942        assert!(
9943            position.quantity.is_zero(),
9944            "Quantity should be zero after adjustment"
9945        );
9946        assert_eq!(
9947            position.signed_qty,
9948            dec!(0.0),
9949            "signed_qty should be normalized to 0.0"
9950        );
9951    }
9952
9953    #[rstest]
9954    fn test_position_spot_buy_partial_fills_with_base_commission() {
9955        // Reproduce GitHub issue #3546: partial fills with base currency commission
9956        // should reduce position quantity, not increase it
9957        let eth_usdt = currency_pair_ethusdt();
9958        let eth_usdt = InstrumentAny::CurrencyPair(eth_usdt);
9959
9960        let order1 = OrderTestBuilder::new(OrderType::Market)
9961            .instrument_id(eth_usdt.id())
9962            .side(OrderSide::Buy)
9963            .quantity(Quantity::from("0.00350"))
9964            .build();
9965
9966        let fill1 = TestOrderEventStubs::filled(
9967            &order1,
9968            &eth_usdt,
9969            Some(TradeId::new("1")),
9970            None,
9971            Some(Price::from("2042.69")),
9972            Some(Quantity::from("0.00350")),
9973            None,
9974            Some(Money::new(0.00001, eth_usdt.base_currency().unwrap())),
9975            None,
9976            None,
9977        );
9978
9979        let mut position = Position::new(&eth_usdt, fill1.into());
9980
9981        assert_eq!(position.quantity, Quantity::from("0.00349"));
9982        assert_eq!(position.signed_qty, dec!(0.00349));
9983        assert_eq!(position.side, PositionSide::Long);
9984        assert_eq!(position.adjustments.len(), 1);
9985        assert_eq!(
9986            position.adjustments[0].quantity_change,
9987            Some(rust_decimal_macros::dec!(-0.00001))
9988        );
9989
9990        let order2 = OrderTestBuilder::new(OrderType::Market)
9991            .instrument_id(eth_usdt.id())
9992            .side(OrderSide::Buy)
9993            .quantity(Quantity::from("0.00350"))
9994            .build();
9995
9996        let fill2 = TestOrderEventStubs::filled(
9997            &order2,
9998            &eth_usdt,
9999            Some(TradeId::new("2")),
10000            None,
10001            Some(Price::from("2042.69")),
10002            Some(Quantity::from("0.00350")),
10003            None,
10004            Some(Money::new(0.00001, eth_usdt.base_currency().unwrap())),
10005            None,
10006            None,
10007        );
10008
10009        position.apply(&fill2.into());
10010
10011        assert_eq!(position.quantity, Quantity::from("0.00698"));
10012        assert_eq!(position.signed_qty, dec!(0.00698));
10013        assert_eq!(position.adjustments.len(), 2);
10014
10015        let order3 = OrderTestBuilder::new(OrderType::Market)
10016            .instrument_id(eth_usdt.id())
10017            .side(OrderSide::Buy)
10018            .quantity(Quantity::from("0.00300"))
10019            .build();
10020
10021        let fill3 = TestOrderEventStubs::filled(
10022            &order3,
10023            &eth_usdt,
10024            Some(TradeId::new("3")),
10025            None,
10026            Some(Price::from("2042.69")),
10027            Some(Quantity::from("0.00300")),
10028            None,
10029            Some(Money::new(0.00001, eth_usdt.base_currency().unwrap())),
10030            None,
10031            None,
10032        );
10033
10034        position.apply(&fill3.into());
10035
10036        // Total filled: 0.01000, total commission: 0.00003
10037        // Position should be 0.01000 - 0.00003 = 0.00997
10038        assert_eq!(position.quantity, Quantity::from("0.00997"));
10039        assert_eq!(position.signed_qty, dec!(0.00997));
10040        assert_eq!(position.side, PositionSide::Long);
10041        assert_eq!(position.adjustments.len(), 3);
10042
10043        // buy_qty tracks order fill amounts, not commission-adjusted
10044        assert_eq!(position.buy_qty, Quantity::from("0.01000"));
10045    }
10046
10047    #[rstest]
10048    fn test_position_spot_sell_partial_fills_with_base_commission() {
10049        let btc_usdt = currency_pair_btcusdt();
10050        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
10051
10052        let order1 = OrderTestBuilder::new(OrderType::Market)
10053            .instrument_id(btc_usdt.id())
10054            .side(OrderSide::Sell)
10055            .quantity(Quantity::from("0.5"))
10056            .build();
10057
10058        let fill1 = TestOrderEventStubs::filled(
10059            &order1,
10060            &btc_usdt,
10061            Some(TradeId::new("1")),
10062            None,
10063            Some(Price::from("50000.0")),
10064            Some(Quantity::from("0.5")),
10065            None,
10066            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
10067            None,
10068            None,
10069        );
10070
10071        let mut position = Position::new(&btc_usdt, fill1.into());
10072
10073        // Short: sold 0.5 + paid 0.001 commission = -0.501 exposure
10074        assert!((position.signed_qty - (dec!(-0.501))).abs() < dec!(1e-9));
10075        assert_eq!(position.side, PositionSide::Short);
10076        assert_eq!(position.adjustments.len(), 1);
10077
10078        let order2 = OrderTestBuilder::new(OrderType::Market)
10079            .instrument_id(btc_usdt.id())
10080            .side(OrderSide::Sell)
10081            .quantity(Quantity::from("0.5"))
10082            .build();
10083
10084        let fill2 = TestOrderEventStubs::filled(
10085            &order2,
10086            &btc_usdt,
10087            Some(TradeId::new("2")),
10088            None,
10089            Some(Price::from("50000.0")),
10090            Some(Quantity::from("0.5")),
10091            None,
10092            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
10093            None,
10094            None,
10095        );
10096
10097        position.apply(&fill2.into());
10098
10099        // Total short: 1.0 sold + 0.002 commission = -1.002
10100        assert!((position.signed_qty - (dec!(-1.002))).abs() < dec!(1e-9));
10101        assert!((position.quantity.as_f64() - 1.002).abs() < 1e-9);
10102        assert_eq!(position.adjustments.len(), 2);
10103        assert_eq!(position.sell_qty, Quantity::from("1.0"));
10104    }
10105
10106    #[rstest]
10107    fn test_position_spot_round_trip_close_flat_with_quote_commission() {
10108        let eth_usdt = currency_pair_ethusdt();
10109        let eth_usdt = InstrumentAny::CurrencyPair(eth_usdt);
10110
10111        let buy_order = OrderTestBuilder::new(OrderType::Market)
10112            .instrument_id(eth_usdt.id())
10113            .side(OrderSide::Buy)
10114            .quantity(Quantity::from("1.00000"))
10115            .build();
10116
10117        let buy_fill = TestOrderEventStubs::filled(
10118            &buy_order,
10119            &eth_usdt,
10120            Some(TradeId::new("1")),
10121            None,
10122            Some(Price::from("2000.00")),
10123            Some(Quantity::from("1.00000")),
10124            None,
10125            Some(Money::new(0.001, eth_usdt.base_currency().unwrap())),
10126            None,
10127            None,
10128        );
10129
10130        let mut position = Position::new(&eth_usdt, buy_fill.into());
10131
10132        // Position = 1.0 - 0.001 = 0.999
10133        assert_eq!(position.quantity, Quantity::from("0.99900"));
10134        assert_eq!(position.side, PositionSide::Long);
10135
10136        let sell_order = OrderTestBuilder::new(OrderType::Market)
10137            .instrument_id(eth_usdt.id())
10138            .side(OrderSide::Sell)
10139            .quantity(Quantity::from("0.99900"))
10140            .build();
10141
10142        let sell_fill = TestOrderEventStubs::filled(
10143            &sell_order,
10144            &eth_usdt,
10145            Some(TradeId::new("2")),
10146            None,
10147            Some(Price::from("2100.00")),
10148            Some(Quantity::from("0.99900")),
10149            None,
10150            Some(Money::new(2.0, Currency::USDT())),
10151            None,
10152            None,
10153        );
10154
10155        position.apply(&sell_fill.into());
10156
10157        assert_eq!(position.side, PositionSide::Flat);
10158        assert_eq!(position.signed_qty, dec!(0.0));
10159        assert!(position.is_closed());
10160        // Only 1 adjustment from the buy (quote commission doesn't create adjustment)
10161        assert_eq!(position.adjustments.len(), 1);
10162
10163        // PnL: 0.999 ETH * $100 price move = $99.90, minus $2 commission
10164        let realized = position.realized_pnl.unwrap().as_f64();
10165        assert!(
10166            (realized - 97.9).abs() < 0.01,
10167            "Realized PnL should be ~97.90 USDT, was {realized}"
10168        );
10169    }
10170
10171    #[rstest]
10172    fn test_position_spot_commission_accumulation_multiple_partial_fills() {
10173        let eth_usdt = currency_pair_ethusdt();
10174        let eth_usdt = InstrumentAny::CurrencyPair(eth_usdt);
10175
10176        let order1 = OrderTestBuilder::new(OrderType::Market)
10177            .instrument_id(eth_usdt.id())
10178            .side(OrderSide::Buy)
10179            .quantity(Quantity::from("0.50000"))
10180            .build();
10181
10182        let fill1 = TestOrderEventStubs::filled(
10183            &order1,
10184            &eth_usdt,
10185            Some(TradeId::new("1")),
10186            None,
10187            Some(Price::from("2000.00")),
10188            Some(Quantity::from("0.50000")),
10189            None,
10190            Some(Money::new(0.0005, eth_usdt.base_currency().unwrap())),
10191            None,
10192            None,
10193        );
10194
10195        let mut position = Position::new(&eth_usdt, fill1.into());
10196
10197        let order2 = OrderTestBuilder::new(OrderType::Market)
10198            .instrument_id(eth_usdt.id())
10199            .side(OrderSide::Buy)
10200            .quantity(Quantity::from("0.50000"))
10201            .build();
10202
10203        let fill2 = TestOrderEventStubs::filled(
10204            &order2,
10205            &eth_usdt,
10206            Some(TradeId::new("2")),
10207            None,
10208            Some(Price::from("2010.00")),
10209            Some(Quantity::from("0.50000")),
10210            None,
10211            Some(Money::new(0.0005, eth_usdt.base_currency().unwrap())),
10212            None,
10213            None,
10214        );
10215
10216        position.apply(&fill2.into());
10217
10218        // Total: 1.0 filled, 0.001 total commission
10219        assert_eq!(position.quantity, Quantity::from("0.99900"));
10220        assert_eq!(position.buy_qty, Quantity::from("1.00000"));
10221
10222        assert_eq!(position.adjustments.len(), 2);
10223        for adj in &position.adjustments {
10224            assert_eq!(adj.adjustment_type, PositionAdjustmentType::Commission);
10225            assert_eq!(
10226                adj.quantity_change,
10227                Some(rust_decimal_macros::dec!(-0.0005))
10228            );
10229        }
10230
10231        let commissions = position.commissions();
10232        assert_eq!(commissions.len(), 1);
10233        let eth_commission = commissions[0];
10234        assert!(
10235            (eth_commission.as_f64() - 0.001).abs() < 1e-9,
10236            "Total ETH commission should be 0.001, was {}",
10237            eth_commission.as_f64()
10238        );
10239    }
10240
10241    #[rstest]
10242    fn test_position_apply_fill_with_earlier_timestamp_adjusts_ts_opened(audusd_sim: CurrencyPair) {
10243        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
10244        let order1 = OrderTestBuilder::new(OrderType::Market)
10245            .instrument_id(audusd_sim.id())
10246            .side(OrderSide::Buy)
10247            .quantity(Quantity::from(100_000))
10248            .build();
10249        let order2 = OrderTestBuilder::new(OrderType::Market)
10250            .instrument_id(audusd_sim.id())
10251            .side(OrderSide::Buy)
10252            .quantity(Quantity::from(100_000))
10253            .build();
10254
10255        // First fill at ts=2000
10256        let fill1 = TestOrderEventStubs::filled(
10257            &order1,
10258            &audusd_sim,
10259            Some(TradeId::new("t1")),
10260            None,
10261            Some(Price::from("1.00001")),
10262            None,
10263            None,
10264            None,
10265            Some(UnixNanos::from(2_000u64)),
10266            None,
10267        );
10268        let mut position = Position::new(&audusd_sim, fill1.into());
10269        assert_eq!(position.ts_opened, UnixNanos::from(2_000u64));
10270
10271        // Second fill at ts=1000 (earlier than position open)
10272        let fill2 = TestOrderEventStubs::filled(
10273            &order2,
10274            &audusd_sim,
10275            Some(TradeId::new("t2")),
10276            None,
10277            Some(Price::from("1.00002")),
10278            None,
10279            None,
10280            None,
10281            Some(UnixNanos::from(1_000u64)),
10282            None,
10283        );
10284
10285        // Should not panic; ts_opened and opening_order_id stay unchanged
10286        position.apply(&fill2.into());
10287        assert_eq!(position.ts_opened, UnixNanos::from(2_000u64));
10288        assert_eq!(position.opening_order_id, order1.client_order_id());
10289        assert_eq!(position.events.len(), 2);
10290    }
10291
10292    #[rstest]
10293    fn test_position_close_before_open_clamps_duration(audusd_sim: CurrencyPair) {
10294        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
10295        let opening_order = OrderTestBuilder::new(OrderType::Market)
10296            .instrument_id(audusd_sim.id())
10297            .side(OrderSide::Buy)
10298            .quantity(Quantity::from(100_000))
10299            .build();
10300        let closing_order = OrderTestBuilder::new(OrderType::Market)
10301            .instrument_id(audusd_sim.id())
10302            .side(OrderSide::Sell)
10303            .quantity(Quantity::from(100_000))
10304            .build();
10305        let opening_fill = TestOrderEventStubs::filled(
10306            &opening_order,
10307            &audusd_sim,
10308            Some(TradeId::new("OPEN")),
10309            None,
10310            Some(Price::from("1.00001")),
10311            None,
10312            None,
10313            None,
10314            Some(UnixNanos::from(2_000u64)),
10315            None,
10316        );
10317        let closing_fill = TestOrderEventStubs::filled(
10318            &closing_order,
10319            &audusd_sim,
10320            Some(TradeId::new("CLOSE")),
10321            None,
10322            Some(Price::from("1.00002")),
10323            None,
10324            None,
10325            None,
10326            Some(UnixNanos::from(1_000u64)),
10327            None,
10328        );
10329        let mut position = Position::new(&audusd_sim, opening_fill.into());
10330
10331        position.apply(&closing_fill.into());
10332
10333        assert_eq!(position.side, PositionSide::Flat);
10334        assert_eq!(position.ts_opened, UnixNanos::from(2_000u64));
10335        assert_eq!(position.ts_closed, Some(UnixNanos::from(1_000u64)));
10336        assert_eq!(position.duration_ns, DurationNanos::default());
10337        assert_eq!(
10338            position.closing_order_id,
10339            Some(closing_order.client_order_id())
10340        );
10341    }
10342
10343    #[rstest]
10344    fn test_position_commissions_multi_currency_insertion_order(audusd_sim: CurrencyPair) {
10345        // Locks in IndexMap iteration order for Position::commissions:
10346        // new currencies append to the end, existing currencies accumulate
10347        // in place. PositionSnapshot.commissions builds its Vec from this
10348        // iteration; the order must be deterministic across runs.
10349        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
10350        let order_template = OrderTestBuilder::new(OrderType::Market)
10351            .instrument_id(audusd_sim.id())
10352            .side(OrderSide::Buy)
10353            .quantity(Quantity::from(100_000))
10354            .build();
10355
10356        let fill_usd = TestOrderEventStubs::filled(
10357            &order_template,
10358            &audusd_sim,
10359            Some(TradeId::new("t1")),
10360            None,
10361            Some(Price::from("1.00001")),
10362            None,
10363            None,
10364            Some(Money::from("1.0 USD")),
10365            None,
10366            None,
10367        );
10368        let mut position = Position::new(&audusd_sim, fill_usd.into());
10369
10370        let fill_usdt = TestOrderEventStubs::filled(
10371            &order_template,
10372            &audusd_sim,
10373            Some(TradeId::new("t2")),
10374            None,
10375            Some(Price::from("1.00001")),
10376            None,
10377            None,
10378            Some(Money::from("2.0 USDT")),
10379            None,
10380            None,
10381        );
10382        position.apply(&fill_usdt.into());
10383
10384        let fill_usd_again = TestOrderEventStubs::filled(
10385            &order_template,
10386            &audusd_sim,
10387            Some(TradeId::new("t3")),
10388            None,
10389            Some(Price::from("1.00001")),
10390            None,
10391            None,
10392            Some(Money::from("0.5 USD")),
10393            None,
10394            None,
10395        );
10396        position.apply(&fill_usd_again.into());
10397
10398        let fill_btc = TestOrderEventStubs::filled(
10399            &order_template,
10400            &audusd_sim,
10401            Some(TradeId::new("t4")),
10402            None,
10403            Some(Price::from("1.00001")),
10404            None,
10405            None,
10406            Some(Money::from("0.0001 BTC")),
10407            None,
10408            None,
10409        );
10410        position.apply(&fill_btc.into());
10411
10412        // USD entered first and accumulates in place, USDT appends second,
10413        // BTC appends third
10414        assert_eq!(
10415            position.commissions(),
10416            vec![
10417                Money::from("1.5 USD"),
10418                Money::from("2.0 USDT"),
10419                Money::from("0.0001 BTC"),
10420            ]
10421        );
10422    }
10423
10424    #[rstest]
10425    fn test_fold_net_position_empty() {
10426        let (net_qty, net_px) = fold_net_position(&[]);
10427        assert_eq!(net_qty, Decimal::ZERO);
10428        assert_eq!(net_px, Decimal::ZERO);
10429    }
10430
10431    #[rstest]
10432    fn test_fold_net_position_single_long() {
10433        let legs = [(dec!(100), dec!(1.5), 1u64)];
10434        let (net_qty, net_px) = fold_net_position(&legs);
10435        assert_eq!(net_qty, dec!(100));
10436        assert_eq!(net_px, dec!(1.5));
10437    }
10438
10439    #[rstest]
10440    fn test_fold_net_position_single_short() {
10441        let legs = [(dec!(-100), dec!(1.5), 1u64)];
10442        let (net_qty, net_px) = fold_net_position(&legs);
10443        assert_eq!(net_qty, dec!(-100));
10444        assert_eq!(net_px, dec!(1.5));
10445    }
10446
10447    #[rstest]
10448    fn test_fold_net_position_same_side_weighted_average() {
10449        // Long 100 @ 1.00, long 200 @ 0.50 -> net 300 @ 0.6667 (rounded weighted avg).
10450        let legs = [(dec!(100), dec!(1.0), 1u64), (dec!(200), dec!(0.5), 2u64)];
10451        let (net_qty, net_px) = fold_net_position(&legs);
10452        assert_eq!(net_qty, dec!(300));
10453        // (100 * 1.0 + 200 * 0.5) / 300 = 200/300 = 0.6666...
10454        assert_eq!(net_px, dec!(200) / dec!(300));
10455    }
10456
10457    #[rstest]
10458    fn test_fold_net_position_partial_close_preserves_avg() {
10459        // Long 300 @ 0.80, short 100 @ 1.00 -> net long 200 @ 0.80 (short closes part of long).
10460        let legs = [
10461            (dec!(300), dec!(0.80), 1u64),
10462            (dec!(-100), dec!(1.00), 2u64),
10463        ];
10464        let (net_qty, net_px) = fold_net_position(&legs);
10465        assert_eq!(net_qty, dec!(200));
10466        assert_eq!(net_px, dec!(0.80));
10467    }
10468
10469    #[rstest]
10470    fn test_fold_net_position_full_close() {
10471        let legs = [(dec!(100), dec!(1.0), 1u64), (dec!(-100), dec!(2.0), 2u64)];
10472        let (net_qty, net_px) = fold_net_position(&legs);
10473        assert_eq!(net_qty, Decimal::ZERO);
10474        assert_eq!(net_px, Decimal::ZERO);
10475    }
10476
10477    #[rstest]
10478    fn test_fold_net_position_single_flip_uses_flipping_price() {
10479        // L100@1, S50@2 partial-closes to L50@1, S100@3 flips to S50 @ 3
10480        let legs = [
10481            (dec!(100), dec!(1.00), 1u64),
10482            (dec!(-50), dec!(2.00), 2u64),
10483            (dec!(-100), dec!(3.00), 3u64),
10484        ];
10485        let (net_qty, net_px) = fold_net_position(&legs);
10486        assert_eq!(net_qty, dec!(-50));
10487        assert_eq!(net_px, dec!(3.00));
10488    }
10489
10490    #[rstest]
10491    fn test_fold_net_position_double_flip() {
10492        // L50, S100 flips to S50@2, B100 flips to L50@3
10493        let legs = [
10494            (dec!(50), dec!(1.00), 1u64),
10495            (dec!(-100), dec!(2.00), 2u64),
10496            (dec!(100), dec!(3.00), 3u64),
10497        ];
10498        let (net_qty, net_px) = fold_net_position(&legs);
10499        assert_eq!(net_qty, dec!(50));
10500        assert_eq!(net_px, dec!(3.00));
10501    }
10502
10503    #[rstest]
10504    fn test_fold_net_position_zero_quantity_legs_skipped() {
10505        // Zero-qty legs are filtered out (closed positions have signed_qty == 0)
10506        let legs = [
10507            (dec!(100), dec!(1.0), 1u64),
10508            (Decimal::ZERO, dec!(99.0), 2u64),
10509            (dec!(50), dec!(2.0), 3u64),
10510        ];
10511        let (net_qty, net_px) = fold_net_position(&legs);
10512        assert_eq!(net_qty, dec!(150));
10513        // (100 * 1.0 + 50 * 2.0) / 150 = 200/150 = 1.333
10514        assert_eq!(net_px, dec!(200) / dec!(150));
10515    }
10516
10517    #[rstest]
10518    fn test_fold_net_position_stable_sort_preserves_input_order_for_equal_ts() {
10519        // Caller owns tie-breaking; this pins the input-order contract for equal-ts legs
10520        let leg_a = (dec!(100), dec!(1.00), 1u64);
10521        let leg_b = (dec!(-100), dec!(2.00), 1u64);
10522
10523        let ab = [leg_a, leg_b];
10524        let ba = [leg_b, leg_a];
10525
10526        // a-then-b: L100@1, S100@2 -> net zero
10527        assert_eq!(fold_net_position(&ab), (Decimal::ZERO, Decimal::ZERO));
10528        // b-then-a: S100@2, B100@1 -> net zero
10529        assert_eq!(fold_net_position(&ba), (Decimal::ZERO, Decimal::ZERO));
10530
10531        // Same-ts legs that do NOT fully cancel: input order picks the surviving avg
10532        let leg_c = (dec!(150), dec!(1.00), 1u64);
10533        let leg_d = (dec!(-100), dec!(2.00), 1u64);
10534        let cd = [leg_c, leg_d];
10535        let dc = [leg_d, leg_c];
10536        // c-then-d: L150@1, S100@2 -> long 50 @ 1
10537        assert_eq!(fold_net_position(&cd), (dec!(50), dec!(1.00)));
10538        // d-then-c: S100@2, B150@1 -> flip to long, residual @ 1
10539        assert_eq!(fold_net_position(&dc), (dec!(50), dec!(1.00)));
10540    }
10541
10542    #[rstest]
10543    fn test_fold_net_position_close_then_reopen() {
10544        // A leg after a full close opens fresh (new net, new avg)
10545        let legs = [
10546            (dec!(100), dec!(1.00), 1u64),
10547            (dec!(-100), dec!(1.50), 2u64),
10548            (dec!(50), dec!(3.00), 3u64),
10549        ];
10550        let (net_qty, net_px) = fold_net_position(&legs);
10551        assert_eq!(net_qty, dec!(50));
10552        assert_eq!(net_px, dec!(3.00));
10553    }
10554
10555    #[rstest]
10556    fn test_fold_net_position_orders_by_ts_opened() {
10557        // Sorted vs shuffled input must fold to the same result.
10558        let in_order = [
10559            (dec!(100), dec!(1.00), 1u64),
10560            (dec!(-50), dec!(2.00), 2u64),
10561            (dec!(-100), dec!(3.00), 3u64),
10562        ];
10563        let shuffled = [
10564            (dec!(-100), dec!(3.00), 3u64),
10565            (dec!(100), dec!(1.00), 1u64),
10566            (dec!(-50), dec!(2.00), 2u64),
10567        ];
10568        assert_eq!(fold_net_position(&in_order), fold_net_position(&shuffled));
10569    }
10570
10571    // Build a NETTING-mode reference Position by applying fills sorted by ts_opened
10572    // (the same order fold_net_position uses). Returns (signed_qty, avg_px_open) as Decimals.
10573    fn netting_reference(
10574        instrument: &InstrumentAny,
10575        fills: &[(OrderSide, u32, u32, u64)],
10576    ) -> (Decimal, Decimal) {
10577        let mut sorted_fills = fills.to_vec();
10578        sorted_fills.sort_by_key(|(_, _, _, ts)| *ts);
10579
10580        let mut position: Option<Position> = None;
10581
10582        for (idx, &(side, qty, px, ts)) in sorted_fills.iter().enumerate() {
10583            let order = OrderTestBuilder::new(OrderType::Market)
10584                .instrument_id(instrument.id())
10585                .side(side)
10586                .quantity(Quantity::from(qty))
10587                .build();
10588            let fill = TestOrderEventStubs::filled(
10589                &order,
10590                instrument,
10591                Some(TradeId::new(format!("T{idx}").as_str())),
10592                Some(PositionId::new("P-NET")),
10593                Some(Price::from(px.to_string().as_str())),
10594                None,
10595                None,
10596                Some(Money::new(0.0, instrument.quote_currency())),
10597                Some(UnixNanos::from(ts)),
10598                None,
10599            );
10600            let event: OrderFilled = fill.into();
10601            if let Some(p) = position.as_mut() {
10602                p.apply(&event);
10603            } else {
10604                position = Some(Position::new(instrument, event));
10605            }
10606        }
10607        let p = position.expect("at least one fill");
10608        (p.signed_qty, p.avg_px_open)
10609    }
10610
10611    // Build the HEDGING leg list (one leg per fill) as Decimal tuples.
10612    fn hedging_legs(fills: &[(OrderSide, u32, u32, u64)]) -> Vec<(Decimal, Decimal, u64)> {
10613        fills
10614            .iter()
10615            .map(|&(side, qty, px, ts)| {
10616                let signed = if side == OrderSide::Buy {
10617                    Decimal::from(qty)
10618                } else {
10619                    -Decimal::from(qty)
10620                };
10621                (signed, Decimal::from(px), ts)
10622            })
10623            .collect()
10624    }
10625
10626    proptest! {
10627        // For any fill sequence that does not fully close mid-stream, fold_net_position
10628        // produces the same (signed_qty, avg_px_open) as applying the same fills in order
10629        // to a single NETTING-mode Position. Sequences that pass through zero mid-stream are
10630        // filtered out because Position::apply does not reset avg_px_open on the next fill
10631        // after a close (production fills are pre-split before reaching that path).
10632        #[rstest]
10633        fn prop_fold_matches_netting_replay(
10634            fills in proptest::collection::vec(
10635                (
10636                    prop_oneof![Just(OrderSide::Buy), Just(OrderSide::Sell)],
10637                    1u32..1_000u32,
10638                    1u32..100u32,
10639                    0u64..1_000_000u64,
10640                ),
10641                1..6,
10642            )
10643        ) {
10644            // Filter sequences with duplicate ts_opened: equal-ts ties resolve to stable
10645            // input order, but the proptest generator does not preserve ties meaningfully.
10646            let mut seen_ts: AHashSet<u64> = AHashSet::new();
10647            for &(_, _, _, ts) in &fills {
10648                if !seen_ts.insert(ts) {
10649                    prop_assume!(false);
10650                }
10651            }
10652
10653            // Filter sequences that fully close mid-stream on the sorted (ts_opened) order.
10654            // Position::apply on a closed position does not reset avg_px_open on the next
10655            // re-open fill (production fills are pre-split, so the path is not exercised).
10656            let mut sorted_fills = fills.clone();
10657            sorted_fills.sort_by_key(|(_, _, _, ts)| *ts);
10658            let mut running: i64 = 0;
10659            let mut zero_mid = false;
10660
10661            for (idx, &(side, qty, _, _)) in sorted_fills.iter().enumerate() {
10662                let qty_i64 = i64::from(qty);
10663                let signed: i64 = if side == OrderSide::Buy {
10664                    qty_i64
10665                } else {
10666                    -qty_i64
10667                };
10668                running += signed;
10669                if idx + 1 < sorted_fills.len() && running == 0 {
10670                    zero_mid = true;
10671                    break;
10672                }
10673            }
10674            prop_assume!(!zero_mid);
10675
10676            let instrument = InstrumentAny::CurrencyPair(audusd_sim());
10677            let (ref_qty, ref_px) = netting_reference(&instrument, &fills);
10678            let legs = hedging_legs(&fills);
10679            let (fold_qty, fold_px) = fold_net_position(&legs);
10680
10681            prop_assert_eq!(fold_qty, ref_qty);
10682
10683            // avg_px_open is only meaningful when the position is non-flat. Compare via
10684            // f64 round-trip since the reference goes through Position::apply f64 arithmetic;
10685            // fold's full-precision Decimal is more accurate but not exactly equal.
10686            if !ref_qty.is_zero() {
10687                let fold_px_f64 = fold_px.to_f64().unwrap_or(0.0);
10688                let ref_px_f64 = ref_px.to_f64().unwrap_or(0.0);
10689                let max_mag = fold_px_f64.abs().max(ref_px_f64.abs()).max(1.0);
10690                prop_assert!(
10691                    (fold_px_f64 - ref_px_f64).abs() < 1e-9 * max_mag,
10692                    "fold_px {fold_px_f64} vs ref_px {ref_px_f64}",
10693                );
10694            }
10695        }
10696    }
10697
10698    fn matching_fill_void(
10699        fill: &OrderFilled,
10700        voided_qty: Quantity,
10701        commission_voided: Option<Money>,
10702    ) -> OrderFillVoided {
10703        OrderFillVoidedSpec::builder()
10704            .trader_id(fill.trader_id)
10705            .strategy_id(fill.strategy_id)
10706            .instrument_id(fill.instrument_id)
10707            .client_order_id(fill.client_order_id)
10708            .venue_order_id(fill.venue_order_id)
10709            .account_id(fill.account_id)
10710            .trade_id(fill.trade_id)
10711            .voided_qty(voided_qty)
10712            .order_side(fill.order_side)
10713            .order_type(fill.order_type)
10714            .last_px(fill.last_px)
10715            .currency(fill.currency)
10716            .liquidity_side(fill.liquidity_side)
10717            .maybe_position_id(fill.position_id)
10718            .maybe_commission_voided(commission_voided)
10719            .build()
10720    }
10721
10722    #[rstest]
10723    #[case(0, 56, Some((0, 0)))]
10724    #[case(123_450_000, 7, Some((12345, 3)))]
10725    #[case(-123_450_000, 7, Some((-12345, 3)))]
10726    #[case(Decimal::MAX.mantissa() * 10, 1, Some((Decimal::MAX.mantissa(), 0)))]
10727    #[case(Decimal::MAX.mantissa() * 10 + 1, 1, None)]
10728    #[case(10, 29, Some((1, 28)))]
10729    #[case(1, 29, None)]
10730    fn test_raw_conversion_preserves_exact_bounds(
10731        #[case] raw: i128,
10732        #[case] scale: u32,
10733        #[case] expected: Option<(i128, u32)>,
10734    ) {
10735        let actual = from_raw(raw, scale);
10736
10737        match expected {
10738            Some(expected) => {
10739                let actual = actual.unwrap();
10740                assert_eq!((actual.mantissa(), actual.scale()), expected);
10741            }
10742            None => assert!(actual.is_err()),
10743        }
10744    }
10745
10746    proptest! {
10747        #[rstest]
10748        fn prop_raw_conversion_matches_exact_normalization(
10749            mut raw in prop_oneof![any::<i128>(), -Decimal::MAX.mantissa()..=Decimal::MAX.mantissa()],
10750            mut scale in 0_u32..=56,
10751        ) {
10752            let actual = from_raw(raw, scale);
10753            while scale > 0 && raw % 10 == 0 {
10754                raw /= 10;
10755                scale -= 1;
10756            }
10757            let expected = Decimal::try_from_i128_with_scale(raw, scale);
10758
10759            match expected {
10760                Ok(expected) => {
10761                    let actual = actual.unwrap();
10762                    prop_assert_eq!((actual.mantissa(), actual.scale()), (expected.mantissa(), expected.scale()));
10763                }
10764                Err(_) => prop_assert!(actual.is_err()),
10765            }
10766        }
10767
10768        #[rstest]
10769        fn prop_domain_fee_split_matches_exact_ratio(
10770            raw in -MoneyRaw::from(1_000_000_i32)..=MoneyRaw::from(1_000_000_i32),
10771            closing in QuantityRaw::from(1_u32)..=QuantityRaw::from(1_000_000_000_u32),
10772            remainder in QuantityRaw::from(1_u32)..=QuantityRaw::from(1_000_000_000_u32),
10773        ) {
10774            let fee = Money::from_raw(raw, Currency::USD());
10775            let closing = Quantity::from_raw(closing, FIXED_PRECISION);
10776            let total = Quantity::from_raw(closing.raw + remainder, FIXED_PRECISION);
10777            let expected = split_commission(fee, qty(closing).unwrap(), qty(total).unwrap()).unwrap();
10778            let actual = split_commission_qty(fee, closing, total).unwrap();
10779
10780            prop_assert_eq!(actual, expected);
10781            prop_assert_eq!(actual.0.checked_add(actual.1), Some(fee));
10782        }
10783    }
10784
10785    #[cfg(feature = "high-precision")]
10786    #[rstest]
10787    fn test_domain_subtraction_rejects_unsupported_input_before_cancellation() {
10788        let raw = Decimal::MAX.mantissa() as u128 + 1;
10789        let value = Quantity::from_raw(raw, FIXED_PRECISION);
10790
10791        assert!(quantity_sub(value, value, FIXED_PRECISION).is_err());
10792        assert!(money_from_qty(value, Currency::USD()).is_err());
10793    }
10794
10795    #[cfg(feature = "defi")]
10796    #[rstest]
10797    fn test_domain_operations_preserve_mixed_raw_scales() {
10798        let lhs = Quantity::from("1.000000000000000001");
10799        let rhs = Quantity::from("0.5000000000000000");
10800        let sum = quantity_add(lhs, rhs, 16).unwrap();
10801        let difference = quantity_sub(lhs, rhs, 16).unwrap();
10802        let fee = Money::from_raw(-7, Currency::USD());
10803        let split = split_commission_qty(fee, rhs, lhs).unwrap();
10804        let money = money_from_qty(lhs, Currency::USD()).unwrap();
10805
10806        assert_eq!((sum.raw, sum.precision), (1_500_000_000_000_000_001, 18));
10807        assert_eq!(
10808            (difference.raw, difference.precision),
10809            (500_000_000_000_000_001, 18)
10810        );
10811        assert_eq!(
10812            split,
10813            (
10814                Money::from_raw(-3, Currency::USD()),
10815                Money::from_raw(-4, Currency::USD())
10816            )
10817        );
10818        assert_eq!(money, Money::from("1 USD"));
10819    }
10820
10821    #[rstest]
10822    #[case("1.2300", "0.230", 2, "1.46", "1.00")]
10823    #[case("1.23", "0.004", 2, "1.234", "1.226")]
10824    #[case("2", "2", 3, "4.000", "0.000")]
10825    fn test_quantity_operations_preserve_value_and_precision(
10826        #[case] lhs: &str,
10827        #[case] rhs: &str,
10828        #[case] precision: u8,
10829        #[case] sum: &str,
10830        #[case] difference: &str,
10831    ) {
10832        let lhs = Quantity::from(lhs);
10833        let rhs = Quantity::from(rhs);
10834        let sum = Quantity::from(sum);
10835        let difference = Quantity::from(difference);
10836        let actual_sum = quantity_add(lhs, rhs, precision).unwrap();
10837        let actual_difference = quantity_sub(lhs, rhs, precision).unwrap();
10838
10839        assert_eq!(
10840            (actual_sum.raw, actual_sum.precision),
10841            (sum.raw, sum.precision)
10842        );
10843        assert_eq!(
10844            (actual_difference.raw, actual_difference.precision),
10845            (difference.raw, difference.precision),
10846        );
10847    }
10848
10849    #[rstest]
10850    fn test_domain_operations_preserve_fractional_raw_units() {
10851        let value = Quantity {
10852            raw: 1,
10853            precision: 2,
10854        };
10855
10856        let zero = Quantity::zero(2);
10857        let sum = quantity_add(value, zero, 2).unwrap();
10858        let difference = quantity_sub(value, zero, 2).unwrap();
10859        let amount = money_from_qty(value, Currency::USD()).unwrap();
10860
10861        assert_eq!((sum.raw, sum.precision), (1, FIXED_PRECISION));
10862        assert_eq!((difference.raw, difference.precision), (1, FIXED_PRECISION));
10863        assert_eq!(amount, Money::from_raw(1, Currency::USD()));
10864    }
10865
10866    #[rstest]
10867    #[case(5, 1, 4)]
10868    #[case(-5, -1, -4)]
10869    #[case(0, 0, 0)]
10870    fn test_domain_fee_split_conserves_raw_units(
10871        #[case] raw: MoneyRaw,
10872        #[case] closing: MoneyRaw,
10873        #[case] opening: MoneyRaw,
10874    ) {
10875        let fee = Money::from_raw(raw, Currency::USD());
10876        let actual = split_commission_qty(fee, Quantity::from("1"), Quantity::from("3")).unwrap();
10877
10878        assert_eq!(
10879            actual,
10880            (
10881                Money::from_raw(closing, Currency::USD()),
10882                Money::from_raw(opening, Currency::USD()),
10883            ),
10884        );
10885        assert_eq!(actual.0.checked_add(actual.1), Some(fee));
10886    }
10887
10888    #[rstest]
10889    fn test_domain_fee_split_preserves_ratio_after_intermediate_overflow() {
10890        let fee = Money::from("1000000 USD");
10891        let closing_qty = Quantity::from("1000000");
10892        let total_qty = Quantity::from("4000000");
10893        let actual = split_commission_qty(fee, closing_qty, total_qty).unwrap();
10894
10895        assert_eq!(
10896            actual,
10897            (Money::from("250000 USD"), Money::from("750000 USD"))
10898        );
10899        assert_eq!(actual.0.checked_add(actual.1), Some(fee));
10900    }
10901
10902    #[rstest]
10903    fn test_quantity_operations_reject_overflow_and_underflow() {
10904        let max = Quantity::from_raw(crate::types::quantity::QUANTITY_RAW_MAX, FIXED_PRECISION);
10905        let unit = Quantity::from_raw(1, FIXED_PRECISION);
10906
10907        assert!(quantity_add(max, unit, FIXED_PRECISION).is_err());
10908        assert!(quantity_sub(unit, max, FIXED_PRECISION).is_err());
10909    }
10910
10911    #[rstest]
10912    #[case(false)]
10913    #[case(true)]
10914    fn test_fee_allocation_uses_exact_integer_ratio(#[case] rebate: bool) {
10915        let fee =
10916            Money::from_decimal_exact(Decimal::new(1, u32::from(FIXED_PRECISION)), Currency::USD())
10917                .unwrap();
10918
10919        let fee = if rebate { -fee } else { fee };
10920        let (closing, opening) =
10921            split_commission(fee, Decimal::MAX - Decimal::ONE, Decimal::MAX).unwrap();
10922        assert_eq!(closing, Money::zero(Currency::USD()));
10923        assert_eq!(opening, fee);
10924    }
10925
10926    #[rstest]
10927    #[case(5, 0)]
10928    #[case(15, 2)]
10929    #[case(25, 2)]
10930    #[case(-5, 0)]
10931    #[case(-15, -2)]
10932    #[case(-25, -2)]
10933    fn test_money_rounds_native_midpoints_to_even(#[case] coefficient: i64, #[case] expected: i64) {
10934        let amount = Decimal::new(coefficient, u32::from(FIXED_PRECISION) + 1);
10935        let expected = Decimal::new(expected, u32::from(FIXED_PRECISION));
10936
10937        assert_eq!(
10938            money(amount, Currency::USD()).unwrap().as_decimal(),
10939            expected
10940        );
10941    }
10942
10943    #[rstest]
10944    fn test_proportion_preserves_exact_cancellation() {
10945        let allocated = proportion(dec!(11382), Decimal::ONE, dec!(271)).unwrap();
10946        assert_eq!(allocated, dec!(42));
10947        assert_eq!(sub(dec!(11382), allocated).unwrap(), dec!(11340));
10948    }
10949
10950    #[rstest]
10951    fn test_rounded_arithmetic_rejects_underflow() {
10952        assert!(div(dec!(0.0000000000000000000000000001), dec!(10)).is_err());
10953        assert!(mul_rounded(dec!(0.0000000000000001), dec!(0.0000000000000001)).is_err());
10954        assert!(add_rounded(Decimal::MAX, dec!(0.1)).is_err());
10955        assert!(add_rounded(dec!(0.1), Decimal::MAX).is_err());
10956    }
10957
10958    #[rstest]
10959    fn test_pnl_sum_bounds_lost_residual(
10960        #[values(false, true)] reverse: bool,
10961        #[values(Decimal::ONE, Decimal::NEGATIVE_ONE)] sign: Decimal,
10962    ) {
10963        let currency = Currency::USD();
10964        let unit = amount(Money::from_raw(1, currency)).unwrap() * sign;
10965        let residual = unit / dec!(10);
10966        let (lhs, rhs) = if reverse {
10967            (unit, Decimal::MAX)
10968        } else {
10969            (Decimal::MAX, unit)
10970        };
10971
10972        let (lhs_residual, rhs_residual) = if reverse {
10973            (residual, Decimal::MAX)
10974        } else {
10975            (Decimal::MAX, residual)
10976        };
10977
10978        assert!(add_pnl(lhs, rhs, currency).is_err());
10979        assert_eq!(
10980            add_pnl(lhs_residual, rhs_residual, currency).unwrap(),
10981            Decimal::MAX
10982        );
10983        assert_eq!(
10984            add_pnl(Decimal::ONE, residual, currency).unwrap(),
10985            Decimal::ONE + residual
10986        );
10987    }
10988
10989    #[rstest]
10990    fn test_checked_product_rejects_silent_underflow() {
10991        assert!(mul(dec!(0.0000000000000001), dec!(0.0000000000000001)).is_err());
10992        assert_eq!(mul(dec!(1.2345), dec!(0.01)).unwrap(), dec!(0.012345));
10993    }
10994
10995    #[rstest]
10996    fn test_checked_sum_rejects_lost_increment() {
10997        assert!(add(Decimal::MAX, dec!(0.1)).is_err());
10998        assert_eq!(sub(dec!(1.000001), Decimal::ONE).unwrap(), dec!(0.000001));
10999        assert_eq!(
11000            money(dec!(0.000001), Currency::USD()).unwrap().as_decimal(),
11001            dec!(0.000001)
11002        );
11003        assert_eq!(
11004            add(dec!(1000000000), dec!(0.000001)).unwrap(),
11005            dec!(1000000000.000001)
11006        );
11007    }
11008
11009    #[rstest]
11010    #[case(dec!(0.000002), dec!(0.5), dec!(0.000001), dec!(0.000001))]
11011    #[case(dec!(0.006000), dec!(0.9), dec!(0.005400), dec!(0.000600))]
11012    #[case(dec!(-0.006000), dec!(0.9), dec!(-0.005400), dec!(-0.000600))]
11013    fn test_fee_allocation(
11014        #[case] fee: Decimal,
11015        #[case] closing_qty: Decimal,
11016        #[case] closing: Decimal,
11017        #[case] opening: Decimal,
11018    ) {
11019        let fee = Money::from_decimal_exact(fee, Currency::USD()).unwrap();
11020        let (actual_closing, actual_opening) =
11021            split_commission(fee, closing_qty, Decimal::ONE).unwrap();
11022        assert_eq!(actual_closing.as_decimal(), closing);
11023        assert_eq!(actual_opening.as_decimal(), opening);
11024        assert_eq!(actual_closing.checked_add(actual_opening), Some(fee));
11025    }
11026}