1use 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#[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 pub buy_qty: Quantity,
145 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 #[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 #[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 #[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 #[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 #[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 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 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 let preserved_adjustments: Vec<PositionAdjusted> = self
366 .adjustments
367 .iter()
368 .filter(|adj| {
369 adj.adjustment_type != PositionAdjustmentType::Commission
372 })
373 .copied()
374 .collect();
375
376 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 let position_id = self.id;
389 self.reset_derived_state();
390
391 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 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 pub fn apply(&mut self, fill: &OrderFilled) {
478 self.apply_fill(fill, true).expect_display(FAILED);
479 }
480
481 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 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 #[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 #[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 pub fn apply_adjustment(&mut self, adjustment: PositionAdjusted) -> CorrectnessResult<()> {
1219 self.apply_adjustment_state(adjustment, true)
1220 }
1221
1222 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 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 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 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 #[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 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 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 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 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 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 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 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 pub fn total_pnl(&self, last: Price) -> CorrectnessResult<Money> {
1978 self.try_total_pnl(last)
1979 }
1980
1981 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 pub fn unrealized_pnl(&self, last: Price) -> CorrectnessResult<Money> {
2010 self.try_unrealized_pnl(last)
2011 }
2012
2013 #[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 #[must_use]
2025 pub fn is_opposite_side(&self, side: OrderSide) -> bool {
2026 self.entry != side
2027 }
2028
2029 #[must_use]
2031 pub fn symbol(&self) -> Symbol {
2032 self.instrument_id.symbol
2033 }
2034
2035 #[must_use]
2037 pub fn venue(&self) -> Venue {
2038 self.instrument_id.venue
2039 }
2040
2041 #[must_use]
2043 pub fn event_count(&self) -> usize {
2044 self.events.len()
2045 }
2046
2047 #[must_use]
2049 pub fn client_order_ids(&self) -> Vec<ClientOrderId> {
2050 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 #[must_use]
2064 pub fn venue_order_ids(&self) -> Vec<VenueOrderId> {
2065 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 #[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 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 #[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 #[must_use]
2134 pub fn last_event(&self) -> Option<OrderFilled> {
2135 self.events.last().cloned()
2136 }
2137
2138 #[must_use]
2140 pub fn last_trade_id(&self) -> Option<TradeId> {
2141 self.events.last().map(|e| e.trade_id)
2142 }
2143
2144 #[must_use]
2146 pub fn is_long(&self) -> bool {
2147 self.side == PositionSide::Long
2148 }
2149
2150 #[must_use]
2152 pub fn is_short(&self) -> bool {
2153 self.side == PositionSide::Short
2154 }
2155
2156 #[must_use]
2158 pub fn is_open(&self) -> bool {
2159 self.side != PositionSide::Flat && self.ts_closed.is_none()
2160 }
2161
2162 #[must_use]
2164 pub fn is_closed(&self) -> bool {
2165 self.side == PositionSide::Flat && self.ts_closed.is_some()
2166 }
2167
2168 #[must_use]
2173 pub fn is_settled(&self) -> bool {
2174 matches!(
2175 self.replay_events.last(),
2176 Some(PositionReplayEvent::InstrumentClosed(_))
2177 )
2178 }
2179
2180 #[must_use]
2186 pub fn requires_replay_state(&self) -> bool {
2187 !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 #[must_use]
2199 pub fn signed_decimal_qty(&self) -> Decimal {
2200 self.signed_qty
2201 }
2202
2203 #[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#[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 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 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); 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); 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 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.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!(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(ðusdt, order1.quantity(), price1, None, dec!(0.0001));
5146 let fill1 = TestOrderEventStubs::filled(
5147 &order1,
5148 ðusdt,
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(ðusdt, 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(ðusdt, order2.quantity(), price2, None, dec!(0.0001));
5168 let fill2 = TestOrderEventStubs::filled(
5169 &order2,
5170 ðusdt,
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(ðusdt, order3.quantity(), price3, None, dec!(0.0001));
5193 let fill3 = TestOrderEventStubs::filled(
5194 &order3,
5195 ðusdt,
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(ðusdt, order4.quantity(), price4, None, dec!(0.0001));
5221 let fill4 = TestOrderEventStubs::filled(
5222 &order4,
5223 ðusdt,
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(ðusdt, order5.quantity(), price5, None, dec!(0.0001));
5249 let fill5 = TestOrderEventStubs::filled(
5250 &order5,
5251 ðusdt,
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 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 ðusdt,
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(ðusdt, 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 ðusd_bybit,
7088 order.quantity(),
7089 Price::from("375.95"),
7090 None,
7091 dec!(0.00075),
7092 );
7093 let fill = TestOrderEventStubs::filled(
7094 &order,
7095 ðusd_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(ðusd_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)), 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 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 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 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 let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7569
7570 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 assert!(position.is_closed());
7597 assert_eq!(position.ts_closed, Some(UnixNanos::default()));
7598 assert_eq!(position.event_count(), 0);
7599
7600 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 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 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 assert_eq!(
7664 position.event_count(),
7665 0,
7666 "Precondition: event_count must be 0"
7667 );
7668
7669 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 assert_eq!(
7681 position.side,
7682 PositionSide::Flat,
7683 "INV2: Empty shell must be FLAT"
7684 );
7685
7686 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 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 assert_eq!(
7716 position.quantity,
7717 Quantity::zero(audusd_sim.size_precision()),
7718 "INV5: Empty shell quantity must be 0"
7719 );
7720
7721 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 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 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 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 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 use crate::instruments::stubs::crypto_perpetual_ethusdt;
7788 let ethusdt = crypto_perpetual_ethusdt();
7789 let ethusdt = InstrumentAny::CryptoPerpetual(ethusdt);
7790
7791 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 ðusdt,
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(ðusdt, fill.into());
7814
7815 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 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 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 assert_eq!(position.events.len(), 100);
7870 assert_eq!(position.quantity, Quantity::from(1000));
7871
7872 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 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 let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
7891
7892 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 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 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 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 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 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 assert!(position.is_closed());
8000
8001 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 let btc_usdt = currency_pair_btcusdt();
8279 let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
8280
8281 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 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())), 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 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 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 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 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 let btc_usdt = currency_pair_btcusdt();
8828 let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
8829
8830 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 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 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 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 let btc_usdt = currency_pair_btcusdt();
9226 let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);
9227
9228 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 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, uuid4(),
9264 UnixNanos::default(),
9265 UnixNanos::default(),
9266 );
9267 position.apply_adjustment(funding_adjustment).unwrap();
9268 assert_eq!(position.adjustments.len(), 2);
9269
9270 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 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 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 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 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 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 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 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 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 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 let fill = TestOrderEventStubs::filled(
9390 &order,
9391 ð_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(ð_perp, fill.into());
9403
9404 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 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 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 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 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 ð_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(ð_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 ð_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 ð_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 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 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 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 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 ð_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(ð_usdt, buy_fill.into());
10131
10132 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 ð_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 assert_eq!(position.adjustments.len(), 1);
10162
10163 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 ð_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(ð_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 ð_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 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 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 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 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 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 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 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 assert_eq!(net_px, dec!(200) / dec!(300));
10455 }
10456
10457 #[rstest]
10458 fn test_fold_net_position_partial_close_preserves_avg() {
10459 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 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 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 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 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 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 assert_eq!(fold_net_position(&ab), (Decimal::ZERO, Decimal::ZERO));
10528 assert_eq!(fold_net_position(&ba), (Decimal::ZERO, Decimal::ZERO));
10530
10531 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 assert_eq!(fold_net_position(&cd), (dec!(50), dec!(1.00)));
10538 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 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 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 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 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 #[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 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 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 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}