nautilus_model/types/

money.rs

// -------------------------------------------------------------------------------------------------
//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
//  https://nautechsystems.io
//
//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
//  You may not use this file except in compliance with the License.
//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
// -------------------------------------------------------------------------------------------------

//! Represents an amount of money in a specified currency denomination.
//!
//! [`Money`] is an immutable value type for representing monetary amounts with an associated
//! currency. It supports both positive and negative values (for debits, losses, etc.) and
//! enforces currency consistency in arithmetic operations.
//!
//! # Arithmetic behavior
//!
//! Adding or subtracting two `Money` values requires matching effective fixed-point scales.
//! These operations panic on a scale mismatch.
//! Comparisons and hashes account for scale differences without rounding.
//!
//! | Operation         | Result    | Notes                             |
//! |-------------------|-----------|-----------------------------------|
//! | `Money + Money`   | `Money`   | Panics if currencies don't match. |
//! | `Money - Money`   | `Money`   | Panics if currencies don't match. |
//! | `Money + Decimal` | `Decimal` |                                   |
//! | `Money - Decimal` | `Decimal` |                                   |
//! | `Money * Decimal` | `Decimal` |                                   |
//! | `Money / Decimal` | `Decimal` |                                   |
//! | `Money + f64`     | `f64`     |                                   |
//! | `Money - f64`     | `f64`     |                                   |
//! | `Money * f64`     | `f64`     |                                   |
//! | `Money / f64`     | `f64`     |                                   |
//! | `-Money`          | `Money`   |                                   |
//!
//! # Ordering behavior
//!
//! Rust ordering compares currency codes lexicographically, then scale-adjusted amounts.
//! This order supports sorting and ordered collections across currencies, but it does not convert
//! amounts to a common currency. Values with the same currency code compare by numeric value.
//! Python comparisons reject values with different currency codes.
//!
//! # Currency constraints
//!
//! When performing arithmetic between two `Money` values, both must have the same currency.
//! Attempting to add or subtract money with different currencies raises an error.
//!
//! # Immutability
//!
//! `Money` is immutable. All arithmetic operations return new instances.

use std::{
    cmp::Ordering,
    fmt::{Debug, Display},
    hash::{Hash, Hasher},
    ops::{Add, Div, Mul, Neg, Sub},
    str::FromStr,
};

use nautilus_core::{
    correctness::{
        CorrectnessError, CorrectnessResult, CorrectnessResultExt, FAILED,
        check_in_range_inclusive_f64, check_predicate_false, check_predicate_true,
    },
    string::formatting::Separable,
};
use rust_decimal::{Decimal, RoundingStrategy};
use serde::{Deserialize, Deserializer, Serialize};

#[cfg(not(any(feature = "defi", feature = "high-precision")))]
use super::fixed::{f64_to_fixed_i64, fixed_i64_to_f64};
#[cfg(any(feature = "defi", feature = "high-precision"))]
use super::fixed::{f64_to_fixed_i128, fixed_i128_to_f64};
#[cfg(feature = "defi")]
use crate::types::fixed::MAX_FLOAT_PRECISION;
use crate::{
    deserialization::StringInput,
    types::{
        Currency, Quantity,
        fixed::{
            FIXED_PRECISION, FIXED_SCALAR, canonical_raw, check_fixed_precision,
            check_fixed_raw_i128, check_fixed_raw_u128, compare_raw_signed, format_scaled_i128,
            mantissa_exponent_to_fixed_i128, mantissa_exponent_to_raw_checked,
            parse_decimal_mantissa, raw_scales_match, remove_underscores, scaled_raw_to_decimal,
        },
    },
};

// -----------------------------------------------------------------------------
// MoneyRaw
// -----------------------------------------------------------------------------

#[cfg(feature = "high-precision")]
pub type MoneyRaw = i128;

#[cfg(not(feature = "high-precision"))]
pub type MoneyRaw = i64;

// -----------------------------------------------------------------------------

/// The maximum raw money integer value.
///
/// # Safety
///
/// `MONEY_MAX` and `FIXED_SCALAR` are cast to `MoneyRaw` before multiplying, so the
/// scaling uses exact integer arithmetic rather than a lossy `f64` product. The result
/// fits within `MoneyRaw`'s range in both high-precision (i128) and standard-precision
/// (i64) modes, so the multiplication cannot overflow.
#[unsafe(no_mangle)]
#[allow(unsafe_code)]
pub static MONEY_RAW_MAX: MoneyRaw = (MONEY_MAX as MoneyRaw) * (FIXED_SCALAR as MoneyRaw);

/// The minimum raw money integer value.
///
/// # Safety
///
/// `MONEY_MIN` and `FIXED_SCALAR` are cast to `MoneyRaw` before multiplying, so the
/// scaling uses exact integer arithmetic rather than a lossy `f64` product. The result
/// fits within `MoneyRaw`'s range in both high-precision (i128) and standard-precision
/// (i64) modes, so the multiplication cannot overflow.
#[unsafe(no_mangle)]
#[allow(unsafe_code)]
pub static MONEY_RAW_MIN: MoneyRaw = (MONEY_MIN as MoneyRaw) * (FIXED_SCALAR as MoneyRaw);

// -----------------------------------------------------------------------------
// MONEY_MAX
// -----------------------------------------------------------------------------

#[cfg(feature = "high-precision")]
/// The maximum valid money amount that can be represented.
pub const MONEY_MAX: f64 = 17_014_118_346_046.0;

#[cfg(not(feature = "high-precision"))]
/// The maximum valid money amount that can be represented.
pub const MONEY_MAX: f64 = 9_223_372_036.0;

// -----------------------------------------------------------------------------
// MONEY_MIN
// -----------------------------------------------------------------------------

#[cfg(feature = "high-precision")]
/// The minimum valid money amount that can be represented.
pub const MONEY_MIN: f64 = -17_014_118_346_046.0;

#[cfg(not(feature = "high-precision"))]
/// The minimum valid money amount that can be represented.
pub const MONEY_MIN: f64 = -9_223_372_036.0;

// -----------------------------------------------------------------------------

/// Represents an amount of money in a specified currency denomination.
///
/// The currency precision supplies default rounding and minimum display precision.
/// Exact constructors and raw construction retain finer native fixed-point amounts.
///
/// - [`MONEY_MAX`] - Maximum representable money amount
/// - [`MONEY_MIN`] - Minimum representable money amount
#[repr(C)]
#[derive(Clone, Copy, Eq)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.model", frozen, from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass(module = "nautilus_trader.model")
)]
pub struct Money {
    pub(crate) raw: MoneyRaw,
    /// The currency denomination associated with the monetary amount.
    pub currency: Currency,
}

impl Money {
    /// Creates a new [`Money`] instance with correctness checking.
    ///
    /// # Errors
    ///
    /// Returns an error if:
    /// - `amount` is invalid outside the representable range [`MONEY_MIN`, `MONEY_MAX`].
    /// - `currency.precision` exceeds the maximum fixed precision.
    ///
    /// # Notes
    ///
    /// PyO3 requires a `Result` type for proper error handling and stacktrace printing in Python.
    pub fn new_checked(amount: f64, currency: Currency) -> CorrectnessResult<Self> {
        // check_in_range_inclusive_f64 already validates that amount is finite
        // (not NaN or infinite) as part of its range validation logic, so no additional
        // infinity checks are needed here.
        check_in_range_inclusive_f64(amount, MONEY_MIN, MONEY_MAX, "amount")?;

        #[cfg(feature = "defi")]
        if currency.precision > MAX_FLOAT_PRECISION {
            // Floats are only reliable up to ~16 decimal digits of precision regardless of feature flags
            return Err(CorrectnessError::PredicateViolation {
                message: format!(
                    "`currency.precision` exceeded maximum float precision ({MAX_FLOAT_PRECISION}), use `Money::from_wei()` for wei values instead"
                ),
            });
        }

        check_fixed_precision(currency.precision)?;

        #[cfg(feature = "high-precision")]
        let raw = f64_to_fixed_i128(amount, currency.precision);

        #[cfg(not(feature = "high-precision"))]
        let raw = f64_to_fixed_i64(amount, currency.precision);

        Ok(Self { raw, currency })
    }

    /// Creates a new [`Money`] instance.
    ///
    /// # Panics
    ///
    /// Panics if a correctness check fails. See [`Money::new_checked`] for more details.
    #[must_use]
    pub fn new(amount: f64, currency: Currency) -> Self {
        Self::new_checked(amount, currency).expect_display(FAILED)
    }

    /// Creates a new [`Money`] instance from the given `raw` fixed-point value and the specified `currency`.
    ///
    /// # Panics
    ///
    /// Panics if a correctness check fails. See [`Money::from_raw_checked`] for more details.
    #[must_use]
    pub fn from_raw(raw: MoneyRaw, currency: Currency) -> Self {
        Self::from_raw_checked(raw, currency).expect_display(FAILED)
    }

    /// Creates a new [`Money`] instance from the given `raw` fixed-point value and the specified
    /// `currency` with correctness checking.
    ///
    /// # Errors
    ///
    /// Returns an error if:
    /// - `raw` is outside the representable range [`MONEY_RAW_MIN`, `MONEY_RAW_MAX`].
    /// - `currency.precision` exceeds the maximum fixed precision.
    pub fn from_raw_checked(raw: MoneyRaw, currency: Currency) -> CorrectnessResult<Self> {
        if raw < MONEY_RAW_MIN || raw > MONEY_RAW_MAX {
            return Err(CorrectnessError::PredicateViolation {
                message: format!(
                    "`raw` value {raw} exceeded bounds [{MONEY_RAW_MIN}, {MONEY_RAW_MAX}] for Money"
                ),
            });
        }

        check_fixed_precision(currency.precision)?;

        Ok(Self { raw, currency })
    }

    /// Creates a new [`Money`] from a mantissa/exponent pair using pure integer arithmetic.
    ///
    /// The value is `mantissa * 10^exponent`. This avoids all floating-point and Decimal
    /// operations, making it ideal for exchange data that arrives as mantissa/exponent pairs.
    ///
    /// # Panics
    ///
    /// Panics if the resulting raw value exceeds [`MONEY_RAW_MAX`] or [`MONEY_RAW_MIN`].
    #[must_use]
    pub fn from_mantissa_exponent(mantissa: i64, exponent: i8, currency: Currency) -> Self {
        check_fixed_precision(currency.precision).expect_display(FAILED);

        if mantissa == 0 {
            return Self { raw: 0, currency };
        }

        let raw_i128 =
            mantissa_exponent_to_fixed_i128(i128::from(mantissa), exponent, currency.precision)
                .expect("Overflow in Money::from_mantissa_exponent");

        #[allow(
            clippy::useless_conversion,
            reason = "i128 to MoneyRaw is real when not high-precision"
        )]
        let raw: MoneyRaw = raw_i128
            .try_into()
            .expect("Raw value exceeds MoneyRaw range in Money::from_mantissa_exponent");
        assert!(
            raw >= MONEY_RAW_MIN && raw <= MONEY_RAW_MAX,
            "`raw` value {raw} exceeded bounds [{MONEY_RAW_MIN}, {MONEY_RAW_MAX}] for Money"
        );

        Self { raw, currency }
    }

    /// Creates a new [`Money`] instance with a value of zero with the given [`Currency`].
    ///
    /// # Panics
    ///
    /// Panics if `currency.precision` exceeds the maximum allowed by `check_fixed_precision`.
    #[must_use]
    pub fn zero(currency: Currency) -> Self {
        check_fixed_precision(currency.precision).expect_display(FAILED);
        Self { raw: 0, currency }
    }

    /// Returns a copy with raw value rounded to currency precision,
    /// stripping any sub-scale bits.
    #[must_use]
    pub fn normalized(&self) -> Self {
        #[cfg(feature = "high-precision")]
        let raw = super::fixed::correct_raw_i128(self.raw, self.currency.precision);

        #[cfg(not(feature = "high-precision"))]
        let raw = super::fixed::correct_raw_i64(self.raw, self.currency.precision);

        Self {
            raw,
            currency: self.currency,
        }
    }

    /// Returns the stored fixed-point integer without rescaling.
    ///
    /// Use this for serialization and explicit fixed-point conversions. Prefer domain
    /// operations for calculations; the storage scale can differ from display precision.
    ///
    /// Direct field access is restricted to this crate:
    ///
    /// ```compile_fail
    /// use nautilus_model::types::Money;
    /// let value = Money::from("1 USD");
    /// let raw = value.raw;
    /// ```
    #[must_use]
    #[inline]
    pub const fn raw(&self) -> MoneyRaw {
        self.raw
    }

    /// Returns `true` if the value of this instance is zero.
    #[must_use]
    pub fn is_zero(&self) -> bool {
        self.raw == 0
    }

    /// Returns `true` if the value of this instance is positive (> 0).
    #[must_use]
    pub fn is_positive(&self) -> bool {
        self.raw > 0
    }

    /// Returns `true` if the value of this instance is negative (< 0).
    #[must_use]
    pub fn is_negative(&self) -> bool {
        self.raw < 0
    }

    /// Returns the absolute amount in the same currency.
    #[must_use]
    pub fn abs(self) -> Self {
        if self.is_negative() { -self } else { self }
    }

    /// Performs a checked addition, returning `None` on raw integer overflow, when
    /// the result falls outside `[MONEY_RAW_MIN, MONEY_RAW_MAX]`, or when the operands
    /// have mixed raw scales (e.g. a wei-scaled `Money` and a `FIXED_SCALAR`-scaled
    /// `Money`, even if their currency codes match).
    ///
    /// # Panics
    ///
    /// Panics if `self.currency` and `rhs.currency` differ by code (currency mismatch
    /// is a type-system invariant violation, not a recoverable arithmetic condition).
    #[must_use]
    pub fn checked_add(self, rhs: Self) -> Option<Self> {
        assert_eq!(
            self.currency, rhs.currency,
            "Currency mismatch: cannot add {} to {}",
            rhs.currency.code, self.currency.code
        );

        if !raw_scales_match(self.currency.precision, rhs.currency.precision) {
            return None;
        }

        let raw = self.raw.checked_add(rhs.raw)?;
        if raw < MONEY_RAW_MIN || raw > MONEY_RAW_MAX {
            return None;
        }

        Some(Self {
            raw,
            currency: self.currency,
        })
    }

    /// Performs a checked subtraction, returning `None` on raw integer underflow, when
    /// the result falls outside `[MONEY_RAW_MIN, MONEY_RAW_MAX]`, or when the operands
    /// have mixed raw scales (e.g. a wei-scaled `Money` and a `FIXED_SCALAR`-scaled
    /// `Money`, even if their currency codes match).
    ///
    /// # Panics
    ///
    /// Panics if `self.currency` and `rhs.currency` differ by code (currency mismatch
    /// is a type-system invariant violation, not a recoverable arithmetic condition).
    #[must_use]
    pub fn checked_sub(self, rhs: Self) -> Option<Self> {
        assert_eq!(
            self.currency, rhs.currency,
            "Currency mismatch: cannot subtract {} from {}",
            rhs.currency.code, self.currency.code
        );

        if !raw_scales_match(self.currency.precision, rhs.currency.precision) {
            return None;
        }

        let raw = self.raw.checked_sub(rhs.raw)?;
        if raw < MONEY_RAW_MIN || raw > MONEY_RAW_MAX {
            return None;
        }

        Some(Self {
            raw,
            currency: self.currency,
        })
    }

    #[cfg(feature = "high-precision")]
    /// Returns the value of this instance as an `f64`.
    ///
    /// # Panics
    ///
    /// Panics if the `defi` feature is enabled and precision exceeds `MAX_FLOAT_PRECISION` (16).
    #[must_use]
    pub fn as_f64(&self) -> f64 {
        #[cfg(feature = "defi")]
        assert!(
            self.currency.precision <= MAX_FLOAT_PRECISION,
            "Invalid f64 conversion beyond `MAX_FLOAT_PRECISION` (16)"
        );

        fixed_i128_to_f64(self.raw)
    }

    #[cfg(not(feature = "high-precision"))]
    /// Returns the value of this instance as an `f64`.
    #[must_use]
    pub fn as_f64(&self) -> f64 {
        fixed_i64_to_f64(self.raw)
    }

    /// Returns the value of this instance as a `Decimal`.
    ///
    /// Preserves stored fractional digits beyond the currency precision. Values whose
    /// significant digits exceed the 96-bit mantissa of Rust `Decimal` can lose scale during conversion.
    #[must_use]
    pub fn as_decimal(&self) -> Decimal {
        let (raw, precision) = self.raw_at_precision();
        scaled_raw_to_decimal(raw, precision)
    }

    /// Returns a formatted string representation of this instance.
    #[must_use]
    pub fn to_formatted_string(&self) -> String {
        let amount_str = self.to_decimal_string();
        format!(
            "{} {}",
            amount_str.separate_with_underscores(),
            self.currency.code
        )
    }

    pub(crate) fn to_decimal_string(self) -> String {
        let (raw, precision) = self.raw_at_precision();
        format_scaled_i128(raw, precision)
    }

    /// Converts a quantity denominated in `currency` to money without rounding.
    ///
    /// # Errors
    ///
    /// Returns an error if the quantity is invalid, the amount is not exactly representable
    /// at the currency precision, or scaling exceeds the money bounds.
    #[allow(
        clippy::useless_conversion,
        reason = "the raw width differs when high-precision is disabled"
    )]
    pub fn from_quantity(quantity: Quantity, currency: Currency) -> CorrectnessResult<Self> {
        check_predicate_false(quantity.is_undefined(), "quantity was undefined")?;
        Quantity::from_raw_checked(quantity.raw, quantity.precision)?;
        check_fixed_raw_u128(u128::from(quantity.raw), quantity.precision).map_err(|e| {
            CorrectnessError::PredicateViolation {
                message: e.to_string(),
            }
        })?;

        let raw = i128::try_from(u128::from(quantity.raw)).map_err(|_| {
            CorrectnessError::PredicateViolation {
                message: format!("quantity for {currency} exceeds signed raw bounds"),
            }
        })?;

        Self::from_rescaled_raw(raw, quantity.precision, currency, "quantity")
    }

    fn raw_at_precision(&self) -> (i128, u8) {
        let precision_diff = FIXED_PRECISION.saturating_sub(self.currency.precision);
        let scale = MoneyRaw::pow(10, u32::from(precision_diff));
        let mut raw = self.raw;
        if raw % scale == 0 {
            return (Self::raw_as_i128(raw / scale), self.currency.precision);
        }

        let mut precision = FIXED_PRECISION;

        while raw % 10 == 0 {
            raw /= 10;
            precision -= 1;
        }

        (Self::raw_as_i128(raw), precision)
    }

    fn raw_as_i128(raw: MoneyRaw) -> i128 {
        #[allow(
            clippy::useless_conversion,
            reason = "i128::from is a widening conversion when MoneyRaw is i64"
        )]
        i128::from(raw)
    }

    /// Creates a new [`Money`] from a `Decimal` value with specified currency.
    ///
    /// This method provides more reliable parsing by using Decimal arithmetic
    /// to avoid floating-point precision issues during conversion.
    ///
    /// # Errors
    ///
    /// Returns an error if:
    /// - The decimal value cannot be converted to the raw representation.
    /// - Overflow occurs during scaling.
    pub fn from_decimal(decimal: Decimal, currency: Currency) -> CorrectnessResult<Self> {
        let exponent = -(decimal.scale() as i8);
        let raw_i128 =
            mantissa_exponent_to_fixed_i128(decimal.mantissa(), exponent, currency.precision)?;

        #[allow(
            clippy::useless_conversion,
            reason = "i128 to MoneyRaw is real when not high-precision"
        )]
        let raw: MoneyRaw =
            raw_i128
                .try_into()
                .map_err(|_| CorrectnessError::PredicateViolation {
                    message: format!(
                        "Decimal value exceeds MoneyRaw range [{MONEY_RAW_MIN}, {MONEY_RAW_MAX}]"
                    ),
                })?;

        if !(raw >= MONEY_RAW_MIN && raw <= MONEY_RAW_MAX) {
            return Err(CorrectnessError::PredicateViolation {
                message: format!(
                    "Raw value {raw} exceeded bounds [{MONEY_RAW_MIN}, {MONEY_RAW_MAX}] for Money"
                ),
            });
        }

        Ok(Self { raw, currency })
    }

    /// Creates money rounded to the native fixed-point scale with midpoint-to-even rounding.
    ///
    /// Uses the greater of the native scale and the currency precision. The currency
    /// identity and its default display precision remain unchanged.
    ///
    /// # Errors
    ///
    /// Returns an error if the currency precision is invalid or the rounded amount exceeds money bounds.
    pub fn from_decimal_native(decimal: Decimal, currency: Currency) -> CorrectnessResult<Self> {
        let rounded = decimal.round_dp_with_strategy(
            u32::from(FIXED_PRECISION.max(currency.precision)),
            RoundingStrategy::MidpointNearestEven,
        );
        Self::from_decimal_exact(rounded, currency)
    }

    /// Creates money without rounding to the currency precision.
    ///
    /// The native fixed-point scale limits the amount precision. The currency
    /// identity and its default precision remain unchanged.
    ///
    /// # Errors
    ///
    /// Returns an error if the currency precision is invalid, the amount loses precision at the
    /// native scale, or the amount exceeds money bounds.
    pub fn from_decimal_exact(decimal: Decimal, currency: Currency) -> CorrectnessResult<Self> {
        Self::from_exact_parts(decimal.mantissa(), decimal.scale() as i32, currency)
    }

    /// Parses an amount and currency without rounding to the currency precision.
    ///
    /// # Errors
    ///
    /// Returns an error if the input is invalid, its currency is unknown, or its amount
    /// is not exactly representable at the native scale within money bounds.
    pub fn from_str_exact(value: &str) -> Result<Self, String> {
        Self::parse(value, true)
    }

    pub(crate) fn from_decimal_str_exact(value: &str, currency: Currency) -> Result<Self, String> {
        let invalid_decimal = || format!("Invalid decimal value '{value}'");

        let (amount, exponent) = match value.split_once(['e', 'E']) {
            Some((amount, exponent)) => {
                let exponent = exponent.parse::<i16>().map_err(|_| invalid_decimal())?;
                (amount, i32::from(exponent))
            }
            None => (value, 0),
        };

        let amount = if let Some((_, fraction)) = amount.split_once('.') {
            if !fraction.bytes().all(|byte| byte.is_ascii_digit()) {
                return Err(invalid_decimal());
            }

            let trimmed = amount.trim_end_matches('0');
            let trimmed = trimmed.strip_suffix('.').unwrap_or(trimmed);

            if matches!(trimmed, "" | "+" | "-") && !fraction.is_empty() {
                "0"
            } else {
                trimmed
            }
        } else {
            amount
        };

        let (amount, whole_zeros) = if amount.contains('.') {
            (amount, 0)
        } else {
            let trimmed = amount.trim_end_matches('0');
            let zeros = i32::try_from(amount.len() - trimmed.len()).map_err(|e| e.to_string())?;
            if zeros > 0 && matches!(trimmed, "" | "+" | "-") {
                ("0", zeros)
            } else {
                (trimmed, zeros)
            }
        };

        let (mantissa, precision) = parse_decimal_mantissa(amount)?;
        Self::from_exact_parts(
            mantissa,
            i32::from(precision) - exponent - whole_zeros,
            currency,
        )
        .map_err(|e| e.to_string())
    }

    fn from_exact_parts(
        mut mantissa: i128,
        mut precision: i32,
        currency: Currency,
    ) -> CorrectnessResult<Self> {
        check_fixed_precision(currency.precision)?;
        let target_precision = currency.precision.max(FIXED_PRECISION);
        if mantissa == 0 {
            return Ok(Self::zero(currency));
        }

        while precision > i32::from(target_precision) && mantissa % 10 == 0 {
            mantissa /= 10;
            precision -= 1;
        }

        if precision > i32::from(target_precision) {
            return Err(CorrectnessError::PredicateViolation {
                message: format!("amount exceeds native money precision {target_precision}"),
            });
        }

        let exponent =
            i8::try_from(-precision).map_err(|_| CorrectnessError::PredicateViolation {
                message: "amount exceeds native money exponent range".to_string(),
            })?;

        let raw = mantissa_exponent_to_raw_checked::<MoneyRaw>(
            mantissa,
            exponent,
            target_precision,
            "exact Money construction",
            "MoneyRaw",
            "Money",
        )?;
        Self::from_raw_checked(raw, currency)
    }

    #[allow(
        clippy::useless_conversion,
        reason = "the raw width differs when high-precision is disabled"
    )]
    pub(crate) fn from_rescaled_raw(
        raw: i128,
        source_precision: u8,
        currency: Currency,
        subject: &str,
    ) -> CorrectnessResult<Self> {
        check_fixed_precision(source_precision)?;
        check_fixed_precision(currency.precision)?;
        let source_precision = source_precision.max(FIXED_PRECISION);
        let target_precision = currency.precision.max(FIXED_PRECISION);

        let raw = match source_precision.cmp(&target_precision) {
            Ordering::Less => {
                let scale = 10_i128.pow(u32::from(target_precision - source_precision));
                raw.checked_mul(scale)
                    .ok_or_else(|| CorrectnessError::PredicateViolation {
                        message: format!(
                            "{subject} for {currency} overflowed while increasing raw scale"
                        ),
                    })?
            }
            Ordering::Greater => {
                let scale = 10_i128.pow(u32::from(source_precision - target_precision));
                check_predicate_true(
                    raw % scale == 0,
                    &format!("{subject} for {currency} loses precision when decreasing raw scale"),
                )?;
                raw / scale
            }
            Ordering::Equal => raw,
        };

        check_fixed_raw_i128(raw, currency.precision).map_err(|e| {
            CorrectnessError::PredicateViolation {
                message: e.to_string(),
            }
        })?;

        let raw: MoneyRaw = raw
            .try_into()
            .map_err(|_| CorrectnessError::PredicateViolation {
                message: format!("{subject} for {currency} exceeds Money raw bounds"),
            })?;

        Self::from_raw_checked(raw, currency)
    }

    fn parse(value: &str, exact: bool) -> Result<Self, String> {
        let mut parts = value.split_whitespace();

        // Ensure we have both the amount and currency
        let (Some(amount), Some(currency), None) = (parts.next(), parts.next(), parts.next())
        else {
            return Err(format!(
                "Error invalid input format '{value}'. Expected '<amount> <currency>'"
            ));
        };

        let clean_amount = remove_underscores(amount);

        let currency = Currency::from_str(currency).map_err(|e| e.to_string())?;
        if exact {
            return Self::from_decimal_str_exact(&clean_amount, currency);
        }

        if clean_amount.contains('e') || clean_amount.contains('E') {
            let decimal = Decimal::from_scientific(&clean_amount)
                .map_err(|e| format!("Error parsing amount '{amount}' as Decimal: {e}"))?;
            return Self::from_decimal(decimal, currency).map_err(|e| e.to_string());
        }

        let (mantissa, amount_precision) = parse_decimal_mantissa(&clean_amount)?;
        let exponent = -i8::try_from(amount_precision).map_err(|e| e.to_string())?;
        let raw = mantissa_exponent_to_raw_checked::<MoneyRaw>(
            mantissa,
            exponent,
            currency.precision,
            "Money::from_str",
            "MoneyRaw",
            "Money",
        )
        .map_err(|e| e.to_string())?;
        Self::from_raw_checked(raw, currency).map_err(|e| e.to_string())
    }
}

impl FromStr for Money {
    type Err = String;

    fn from_str(value: &str) -> Result<Self, Self::Err> {
        Self::parse(value, false)
    }
}

impl<T: AsRef<str>> From<T> for Money {
    fn from(value: T) -> Self {
        Self::from_str(value.as_ref()).expect(FAILED)
    }
}

impl From<Money> for f64 {
    fn from(money: Money) -> Self {
        money.as_f64()
    }
}

impl From<&Money> for f64 {
    fn from(money: &Money) -> Self {
        money.as_f64()
    }
}

impl Hash for Money {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.raw.signum().hash(state);
        canonical_raw(self.raw.unsigned_abs(), self.currency.precision).hash(state);
        self.currency.hash(state);
    }
}

impl PartialEq for Money {
    fn eq(&self, other: &Self) -> bool {
        self.cmp(other) == Ordering::Equal
    }
}

impl PartialOrd for Money {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for Money {
    fn cmp(&self, other: &Self) -> Ordering {
        self.currency.code.cmp(&other.currency.code).then_with(|| {
            compare_raw_signed(
                self.raw,
                self.currency.precision,
                other.raw,
                other.currency.precision,
            )
        })
    }
}

impl Neg for Money {
    type Output = Self;
    fn neg(self) -> Self::Output {
        Self {
            raw: -self.raw,
            currency: self.currency,
        }
    }
}

impl Add for Money {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        assert_eq!(
            self.currency, rhs.currency,
            "Currency mismatch: cannot add {} to {}",
            rhs.currency.code, self.currency.code
        );
        assert!(
            raw_scales_match(self.currency.precision, rhs.currency.precision),
            "Cannot add `Money` values with mismatched decimal scales"
        );
        Self {
            raw: self
                .raw
                .checked_add(rhs.raw)
                .expect("Overflow occurred when adding `Money`"),
            currency: self.currency,
        }
    }
}

impl Sub for Money {
    type Output = Self;
    fn sub(self, rhs: Self) -> Self::Output {
        assert_eq!(
            self.currency, rhs.currency,
            "Currency mismatch: cannot subtract {} from {}",
            rhs.currency.code, self.currency.code
        );
        assert!(
            raw_scales_match(self.currency.precision, rhs.currency.precision),
            "Cannot subtract `Money` values with mismatched decimal scales"
        );
        Self {
            raw: self
                .raw
                .checked_sub(rhs.raw)
                .expect("Underflow occurred when subtracting `Money`"),
            currency: self.currency,
        }
    }
}

impl Add<Decimal> for Money {
    type Output = Decimal;
    fn add(self, rhs: Decimal) -> Self::Output {
        self.as_decimal() + rhs
    }
}

impl Sub<Decimal> for Money {
    type Output = Decimal;
    fn sub(self, rhs: Decimal) -> Self::Output {
        self.as_decimal() - rhs
    }
}

impl Mul<Decimal> for Money {
    type Output = Decimal;
    fn mul(self, rhs: Decimal) -> Self::Output {
        self.as_decimal() * rhs
    }
}

impl Div<Decimal> for Money {
    type Output = Decimal;
    fn div(self, rhs: Decimal) -> Self::Output {
        self.as_decimal() / rhs
    }
}

impl Add<f64> for Money {
    type Output = f64;
    fn add(self, rhs: f64) -> Self::Output {
        self.as_f64() + rhs
    }
}

impl Sub<f64> for Money {
    type Output = f64;
    fn sub(self, rhs: f64) -> Self::Output {
        self.as_f64() - rhs
    }
}

impl Mul<f64> for Money {
    type Output = f64;
    fn mul(self, rhs: f64) -> Self::Output {
        self.as_f64() * rhs
    }
}

impl Div<f64> for Money {
    type Output = f64;
    fn div(self, rhs: f64) -> Self::Output {
        self.as_f64() / rhs
    }
}

impl Debug for Money {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let amount = self.to_decimal_string();
        write!(f, "Money({amount}, {})", self.currency)
    }
}

impl Display for Money {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let amount = self.to_decimal_string();
        write!(f, "{amount} {}", self.currency)
    }
}

impl Serialize for Money {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(&self.to_string())
    }
}

impl<'de> Deserialize<'de> for Money {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let StringInput(money_str) = Deserialize::deserialize(deserializer)?;
        Self::from_str_exact(money_str.as_ref()).map_err(serde::de::Error::custom)
    }
}

/// Checks if the money `value` is positive.
///
/// # Errors
///
/// Returns an error if `value` is not positive.
#[inline(always)]
pub fn check_positive_money(value: Money, param: &str) -> CorrectnessResult<()> {
    if value.raw <= 0 {
        return Err(CorrectnessError::NotPositive {
            param: param.to_string(),
            value: value.to_string(),
            type_name: "`Money`",
        });
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use nautilus_core::{approx_eq, correctness::CorrectnessError};
    use rstest::rstest;
    use rust_decimal_macros::dec;

    use super::*;
    use crate::enums::CurrencyType;

    #[rstest]
    #[case(dec!(1.0001), "1.0001 USD")]
    #[case(dec!(0.000001), "0.000001 USD")]
    #[case(dec!(-0.000001), "-0.000001 USD")]
    #[case(dec!(1234.500100), "1234.5001 USD")]
    #[case(dec!(1.230000), "1.23 USD")]
    #[case(dec!(0.000000), "0.00 USD")]
    fn test_exact_usd_roundtrip(#[case] amount: Decimal, #[case] expected: &str) {
        let money = Money::from_decimal_exact(amount, Currency::USD()).unwrap();
        let text = money.to_string();
        let json = serde_json::to_vec(&money).unwrap();
        let msgpack = rmp_serde::to_vec(&money).unwrap();
        let from_text = Money::from_str_exact(&text).unwrap();
        let from_json: Money = serde_json::from_slice(&json).unwrap();
        let from_msgpack: Money = rmp_serde::from_slice(&msgpack).unwrap();

        assert_eq!(money.currency, Currency::USD());
        assert_eq!(money.currency.precision, 2);
        assert_eq!(money.as_decimal(), amount);
        assert_eq!(text, expected);
        assert_eq!(
            format!("{money:?}"),
            format!(
                "Money({}, USD)",
                expected.split_whitespace().next().unwrap()
            )
        );
        assert_eq!(from_text, money);
        assert_eq!(from_json, money);
        assert_eq!(from_msgpack, money);
    }

    #[rstest]
    fn test_exact_money_arithmetic() {
        let balance = Money::from_decimal_exact(dec!(1.0001), Currency::USD()).unwrap();
        let fee = Money::from_decimal_exact(dec!(0.000001), Currency::USD()).unwrap();

        assert_eq!((balance + fee).as_decimal(), dec!(1.000101));
        assert_eq!((balance - fee).as_decimal(), dec!(1.000099));
        assert_eq!((-fee).as_decimal(), dec!(-0.000001));
        assert_eq!((fee * dec!(3)), dec!(0.000003));
        assert_eq!(balance.to_formatted_string(), "1.0001 USD");
        assert_eq!(balance.normalized().as_decimal(), dec!(1.00));
    }

    #[rstest]
    #[case(1)]
    #[case(-1)]
    fn test_exact_money_native_precision_roundtrip(#[case] raw: MoneyRaw) {
        let sign = if raw < 0 { "-" } else { "" };
        let amount = format!("{sign}0.{}1", "0".repeat(usize::from(FIXED_PRECISION - 1)));
        let decimal = Decimal::from_str(&amount).unwrap();
        let expected = Money::from_raw(raw, Currency::USD());
        let from_decimal = Money::from_decimal_exact(decimal, Currency::USD()).unwrap();
        let text = format!("{amount} USD");
        let from_text = Money::from_str_exact(&text).unwrap();

        assert_eq!(from_decimal, expected);
        assert_eq!(from_text, expected);
        assert_eq!(from_decimal.as_decimal(), decimal);
        assert_eq!(from_decimal.to_string(), text);
        assert_eq!(from_decimal.currency.precision, 2);
    }

    #[rstest]
    fn test_exact_money_rejects_native_precision_loss() {
        let amount = format!("0.{}1", "0".repeat(usize::from(FIXED_PRECISION)));
        let decimal = Decimal::from_str(&amount).unwrap();

        assert!(Money::from_decimal_exact(decimal, Currency::USD()).is_err());
        assert!(Money::from_str_exact(&format!("{amount} USD")).is_err());
    }

    #[rstest]
    #[case(usize::from(FIXED_PRECISION) + 1)]
    #[case(39)]
    fn test_exact_money_accepts_extra_zero_digits(#[case] zeros: usize) {
        let amount = format!("1.{}", "0".repeat(zeros));
        let money = Money::from_str_exact(&format!("{amount} USD")).unwrap();

        assert_eq!(money.as_decimal(), dec!(1.00));
        assert_eq!(money.to_string(), "1.00 USD");
    }

    #[rstest]
    #[case("")]
    #[case("-")]
    fn test_exact_money_normalizes_scientific_integer(#[case] sign: &str) {
        let amount = format!("{sign}1{}e-39 USD", "0".repeat(39));
        let money = Money::from_str_exact(&amount).unwrap();
        let decimal_amount = format!("{sign}1{}.0e-39 USD", "0".repeat(39));
        let decimal_money = Money::from_str_exact(&decimal_amount).unwrap();

        assert_eq!(money.to_string(), format!("{sign}1.00 USD"));
        assert_eq!(money.currency, Currency::USD());
        assert_eq!(decimal_money, money);
    }

    #[rstest]
    #[case("e0")]
    #[case("E0")]
    #[case("")]
    fn test_exact_money_rejects_digits_beyond_decimal_capacity(#[case] exponent: &str) {
        let amount = format!("1.{}1{exponent} USD", "0".repeat(28));

        assert_eq!(
            Money::from_str_exact(&amount),
            Err(format!(
                "amount exceeds native money precision {FIXED_PRECISION}"
            ))
        );
    }

    #[rstest]
    #[case("1.0001e0 USD", "1.0001 USD")]
    #[case("1.234e-3 USD", "0.001234 USD")]
    #[case("1.000001E+2 USD", "100.0001 USD")]
    #[case("-.0000 USD", "0.00 USD")]
    #[case("0e32767 USD", "0.00 USD")]
    fn test_exact_money_scientific(#[case] input: &str, #[case] expected: &str) {
        let money = Money::from_str_exact(input).unwrap();

        assert_eq!(money.to_string(), expected);
        assert_eq!(money.currency, Currency::USD());
    }

    #[rstest]
    #[case("not-a-number")]
    #[case("None")]
    #[case("1e")]
    #[case("1e1.5")]
    fn test_exact_money_rejects_invalid_exponent(#[case] amount: &str) {
        let result = Money::from_str_exact(&format!("{amount} USD"));

        assert_eq!(result, Err(format!("Invalid decimal value '{amount}'")));
    }

    #[rstest]
    #[case("1..0")]
    #[case("1.2.3")]
    #[case("-")]
    #[case(".")]
    #[case("+-1")]
    #[case("1.5x0")]
    fn test_exact_money_rejects_malformed_amount(#[case] amount: &str) {
        let result = Money::from_str_exact(&format!("{amount} USD"));

        assert!(result.is_err());
    }

    #[rstest]
    fn test_exact_money_overflow_context() {
        let result = Money::from_str_exact("1e100 USD");

        assert_eq!(
            result,
            Err(format!(
                "Overflow in exact Money construction (mantissa=1, exponent=100, precision={FIXED_PRECISION})"
            ))
        );
    }

    #[rstest]
    fn test_exact_money_rejects_overflow() {
        let maximum = Money::from_raw(MONEY_RAW_MAX, Currency::USD()).as_decimal();
        let minimum = Money::from_raw(MONEY_RAW_MIN, Currency::USD()).as_decimal();

        assert!(Money::from_decimal_exact(maximum + Decimal::ONE, Currency::USD()).is_err());
        assert!(Money::from_decimal_exact(minimum - Decimal::ONE, Currency::USD()).is_err());
        assert_eq!(
            Money::from_decimal_exact(maximum, Currency::USD())
                .unwrap()
                .raw(),
            MONEY_RAW_MAX
        );
        assert_eq!(
            Money::from_decimal_exact(minimum, Currency::USD())
                .unwrap()
                .raw(),
            MONEY_RAW_MIN
        );
    }

    #[cfg(feature = "high-precision")]
    #[rstest]
    fn test_as_decimal_above_decimal_mantissa() {
        // Regression: a precision-16 currency amount above roughly 7.92e12 rescales to a raw
        // value beyond `Decimal`'s 96-bit mantissa, which used to panic during conversion.
        let currency = Currency::new("XYZ", 16, 0, "XYZ", crate::enums::CurrencyType::Crypto);
        let money = Money::from_raw(MONEY_RAW_MAX, currency);

        assert_eq!(money.as_decimal(), dec!(17014118346046));
    }

    #[rstest]
    fn test_money_ordering_is_structural_across_currencies() {
        use std::collections::BTreeSet;

        let aud_low = Money::new(-1.0, Currency::AUD());
        let aud_high = Money::new(100.0, Currency::AUD());
        let usd_low = Money::new(-100.0, Currency::USD());
        let usd_high = Money::new(1.0, Currency::USD());

        assert_eq!(aud_high.cmp(&usd_low), Ordering::Less);
        assert_eq!(aud_high.partial_cmp(&usd_low), Some(Ordering::Less));
        assert_eq!(
            (
                aud_high < usd_low,
                aud_high <= usd_low,
                aud_high > usd_low,
                aud_high >= usd_low,
                usd_low < aud_high,
                usd_low <= aud_high,
                usd_low > aud_high,
                usd_low >= aud_high,
            ),
            (true, true, false, false, false, false, true, true),
        );

        let expected = vec![aud_low, aud_high, usd_low, usd_high];
        let mut sorted = vec![usd_high, aud_high, usd_low, aud_low];
        sorted.sort();
        let ordered = BTreeSet::from([usd_high, aud_high, usd_low, aud_low]);

        assert_eq!(sorted, expected);
        assert_eq!(ordered.into_iter().collect::<Vec<_>>(), expected);
    }

    #[rstest]
    fn test_money_cmp_equal_matches_equality() {
        use crate::enums::CurrencyType;

        let currency = Currency::new("TST", 2, 1, "Test fiat", CurrencyType::Fiat);
        let same_code = Currency::new("TST", 8, 2, "Test crypto", CurrencyType::Crypto);
        let other_code = Currency::new("TSU", 2, 1, "Other fiat", CurrencyType::Fiat);
        let money = Money::from_raw(1, currency);
        let cases = [
            (Money::from_raw(1, same_code), true),
            (Money::from_raw(2, same_code), false),
            (Money::from_raw(1, other_code), false),
        ];

        for (other, expected_equal) in cases {
            assert_eq!(money == other, expected_equal);
            assert_eq!(money.cmp(&other) == Ordering::Equal, expected_equal);
        }
    }

    #[rstest]
    fn test_from_quantity_rejects_noncanonical_raw() {
        let precision = FIXED_PRECISION - 1;
        let quantity = Quantity::from_raw(1, precision);
        let currency = Currency::new("TOKEN", FIXED_PRECISION, 0, "Token", CurrencyType::Crypto);
        let result = Money::from_quantity(quantity, currency);

        assert_eq!(
            result,
            Err(CorrectnessError::PredicateViolation {
                message: format!(
                    "Invalid fixed-point raw value 1 for precision {precision}: \
                             remainder 1 when divided by scale 10. Raw value should be a multiple of 10. \
                             This indicates data corruption or incorrect precision/scaling upstream"
                ),
            })
        );
    }

    #[rstest]
    fn test_extreme_money_round_trips_through_raw() {
        // Regression: a lossy `f64` scalar previously left `MONEY_RAW_MAX`/`MONEY_RAW_MIN`
        // beyond the raw produced by `new` at the bounds, causing spurious panics and errors.
        let max = Money::new(MONEY_MAX, Currency::USD());
        let min = Money::new(MONEY_MIN, Currency::USD());

        assert_eq!(max.raw, MONEY_RAW_MAX);
        assert_eq!(min.raw, MONEY_RAW_MIN);
        assert!(Money::from_raw_checked(max.raw, Currency::USD()).is_ok());
        assert!(Money::from_raw_checked(min.raw, Currency::USD()).is_ok());
    }

    #[cfg(all(feature = "defi", feature = "high-precision"))]
    #[rstest]
    fn test_wei_above_decimal_mantissa_formats_exactly() {
        let raw = 80_000_000_000_000_000_250_000_000_000_i128;
        let currency = Currency::new("ETH", 18, 0, "Ether", crate::enums::CurrencyType::Crypto);
        let money = Money::from_raw(raw, currency);

        assert_eq!(money.to_string(), "80000000000.000000250000000000 ETH");
        assert_eq!(
            money.to_formatted_string(),
            "80_000_000_000.000000250000000000 ETH"
        );
    }

    #[cfg(all(feature = "defi", feature = "high-precision"))]
    #[rstest]
    fn test_exact_money_wei_precision_boundary() {
        let currency = Currency::new(
            "EXACT18",
            crate::defi::WEI_PRECISION,
            0,
            "Exact token",
            CurrencyType::Crypto,
        );
        Currency::register(currency, true).unwrap();
        let amount = dec!(0.000000000000000001);
        let text = "0.000000000000000001 EXACT18";
        let from_decimal = Money::from_decimal_exact(amount, currency).unwrap();
        let from_text = Money::from_str_exact(text).unwrap();
        let too_fine = dec!(0.0000000000000000001);
        let expected = format!(
            "amount exceeds native money precision {}",
            currency.precision
        );

        assert_eq!(from_decimal.raw(), 1);
        assert_eq!(from_decimal.currency, currency);
        assert_eq!(from_decimal.currency.precision, 18);
        assert_eq!(from_decimal.as_decimal(), amount);
        assert_eq!(from_decimal.to_string(), text);
        assert_eq!(from_text, from_decimal);
        assert_eq!(
            Money::from_decimal_exact(too_fine, currency),
            Err(CorrectnessError::PredicateViolation {
                message: expected.clone(),
            })
        );
        assert_eq!(
            Money::from_str_exact("0.0000000000000000001 EXACT18"),
            Err(expected)
        );
    }

    #[cfg(all(feature = "defi", feature = "high-precision"))]
    #[rstest]
    fn test_wei_money_serde_json_round_trip() {
        let currency = Currency::new(
            "WXW",
            18,
            0,
            "Wei exact",
            crate::enums::CurrencyType::Crypto,
        );
        Currency::register(currency, true).unwrap();
        let money = Money::from_raw(80_000_000_000_000_000_250_000_000_000_i128, currency);

        let json = serde_json::to_string(&money).unwrap();
        let deserialized = serde_json::from_str::<Money>(&json).unwrap();

        assert_eq!(json, "\"80000000000.000000250000000000 WXW\"");
        assert_eq!(deserialized, money);
    }

    #[rstest]
    fn test_debug() {
        let money = Money::new(1010.12, Currency::USD());
        let result = format!("{money:?}");
        let expected = "Money(1010.12, USD)";
        assert_eq!(result, expected);
    }

    #[rstest]
    #[case(dec!(9007199253.999999999), "Money(9007199253.999999999, TST9)")]
    #[case(dec!(-9007199253.999999999), "Money(-9007199253.999999999, TST9)")]
    fn test_debug_preserves_exact_amount(#[case] amount: Decimal, #[case] expected: &str) {
        use crate::enums::CurrencyType;

        let currency = Currency::new("TST9", 9, 0, "Test 9dp", CurrencyType::Crypto);
        let money = Money::from_decimal(amount, currency).unwrap();

        assert_eq!(format!("{money:?}"), expected);
    }

    #[rstest]
    fn test_debug_preserves_domain_maximum() {
        use crate::enums::CurrencyType;

        let currency = Currency::new(
            "TST",
            FIXED_PRECISION,
            0,
            "Test fixed precision",
            CurrencyType::Crypto,
        );
        let money = Money::from_raw(MONEY_RAW_MAX, currency);
        let expected = if cfg!(feature = "high-precision") {
            "Money(17014118346046.0000000000000000, TST)"
        } else {
            "Money(9223372036.000000000, TST)"
        };

        assert_eq!(format!("{money:?}"), expected);
    }

    #[rstest]
    fn test_display() {
        let money = Money::new(1010.12, Currency::USD());
        let result = format!("{money}");
        let expected = "1010.12 USD";
        assert_eq!(result, expected);
    }

    #[rstest]
    #[case(42.0, 0, "JPY", "Money(42, JPY)", "42 JPY")]
    #[case(0.0, 2, "USD", "Money(0.00, USD)", "0.00 USD")]
    #[case(-1010.12, 2, "USD", "Money(-1010.12, USD)", "-1010.12 USD")]
    #[case(1010.12, 2, "USD", "Money(1010.12, USD)", "1010.12 USD")] // Normal precision
    #[case(123.456_789, 8, "BTC", "Money(123.45678900, BTC)", "123.45678900 BTC")] // At max normal precision
    fn test_formatting_normal_precision(
        #[case] value: f64,
        #[case] precision: u8,
        #[case] currency_code: &str,
        #[case] expected_debug: &str,
        #[case] expected_display: &str,
    ) {
        use crate::enums::CurrencyType;
        let currency = Currency::new(
            currency_code,
            precision,
            0,
            currency_code,
            CurrencyType::Fiat,
        );
        let money = Money::new(value, currency);

        assert_eq!(format!("{money:?}"), expected_debug);
        assert_eq!(format!("{money}"), expected_display);
    }

    #[rstest]
    #[cfg(feature = "defi")]
    #[case(
        1_000_000_000_000_000_000_i128,
        18,
        "wei",
        "Money(1.000000000000000000, wei)",
        "1.000000000000000000 wei"
    )] // High precision
    #[case(
        2_500_000_000_000_000_000_i128,
        18,
        "ETH",
        "Money(2.500000000000000000, ETH)",
        "2.500000000000000000 ETH"
    )] // High precision
    fn test_formatting_high_precision(
        #[case] raw_value: i128,
        #[case] precision: u8,
        #[case] currency_code: &str,
        #[case] expected_debug: &str,
        #[case] expected_display: &str,
    ) {
        use crate::enums::CurrencyType;
        let currency = Currency::new(
            currency_code,
            precision,
            0,
            currency_code,
            CurrencyType::Crypto,
        );
        let money = Money::from_raw(raw_value, currency);

        assert_eq!(format!("{money:?}"), expected_debug);
        assert_eq!(format!("{money}"), expected_display);
        assert_eq!(
            serde_json::to_value(money).unwrap(),
            serde_json::Value::String(expected_display.to_string()),
        );
    }

    #[rstest]
    fn test_zero_constructor() {
        let usd = Currency::USD();
        let money = Money::zero(usd);
        assert_eq!(money.raw, 0);
        assert_eq!(money.currency, usd);
    }

    #[rstest]
    #[should_panic(expected = "Currency mismatch")]
    fn test_money_different_currency_addition() {
        let usd = Money::new(1000.0, Currency::USD());
        let btc = Money::new(1.0, Currency::BTC());
        let _ = usd + btc; // This should panic since currencies are different
    }

    #[rstest] // Test does not panic rather than exact value
    fn test_with_maximum_value() {
        let money = Money::new_checked(MONEY_MAX, Currency::USD());
        assert!(money.is_ok());
    }

    #[rstest] // Test does not panic rather than exact value
    fn test_with_minimum_value() {
        let money = Money::new_checked(MONEY_MIN, Currency::USD());
        assert!(money.is_ok());
    }

    #[rstest]
    fn test_new_checked_returns_typed_error_with_stable_display() {
        let error = Money::new_checked(MONEY_MAX + 1.0, Currency::USD()).unwrap_err();

        assert!(matches!(error, CorrectnessError::OutOfRange { .. }));
        assert_eq!(
            error.to_string(),
            format!(
                "invalid f64 for 'amount' not in range [{MONEY_MIN}, {MONEY_MAX}], was {}",
                MONEY_MAX + 1.0
            )
        );
    }

    #[cfg(not(feature = "defi"))]
    #[rstest]
    fn test_new_checked_invalid_currency_precision_returns_error() {
        let mut currency = Currency::USD();
        currency.precision = FIXED_PRECISION + 1;

        let error = Money::new_checked(1.0, currency).unwrap_err();
        assert!(
            error
                .to_string()
                .contains("`precision` exceeded maximum `FIXED_PRECISION`"),
            "unexpected message: {error}"
        );
    }

    #[cfg(feature = "defi")]
    #[rstest]
    fn test_new_checked_rejects_float_for_wei_currency() {
        use crate::enums::CurrencyType;

        let currency = Currency::new("TST18", 18, 0, "Test token", CurrencyType::Crypto);
        let error = Money::new_checked(1.0, currency).unwrap_err();
        let message = "`currency.precision` exceeded maximum float precision (16), use \
                       `Money::from_wei()` for wei values instead";

        assert_eq!(
            error,
            CorrectnessError::PredicateViolation {
                message: message.to_string(),
            }
        );
        assert_eq!(error.to_string(), message);
    }

    #[rstest]
    fn test_money_is_zero() {
        let zero_usd = Money::new(0.0, Currency::USD());
        assert!(zero_usd.is_zero());
        assert_eq!(zero_usd, Money::from("0.0 USD"));

        let non_zero_usd = Money::new(100.0, Currency::USD());
        assert!(!non_zero_usd.is_zero());
    }

    #[rstest]
    fn test_money_is_positive() {
        let usd = Currency::USD();
        assert!(Money::new(100.0, usd).is_positive());
        assert!(!Money::new(0.0, usd).is_positive());
        assert!(!Money::new(-100.0, usd).is_positive());
    }

    #[rstest]
    fn test_money_comparisons() {
        let usd = Currency::USD();
        let m1 = Money::new(100.0, usd);
        let m2 = Money::new(200.0, usd);

        assert!(m1 < m2);
        assert!(m2 > m1);
        assert!(m1 <= m2);
        assert!(m2 >= m1);
        assert_eq!(m1.cmp(&m2), Ordering::Less);
        assert_eq!(m2.cmp(&m1), Ordering::Greater);

        // Equality
        let m3 = Money::new(100.0, usd);
        assert_eq!(m1, m3);
    }

    #[rstest]
    fn test_add() {
        let a = 1000.0;
        let b = 500.0;
        let money1 = Money::new(a, Currency::USD());
        let money2 = Money::new(b, Currency::USD());
        let money3 = money1 + money2;
        assert_eq!(money3.raw, Money::new(a + b, Currency::USD()).raw);
    }

    #[rstest]
    fn test_sub() {
        let usd = Currency::USD();
        let money1 = Money::new(1000.0, usd);
        let money2 = Money::new(250.0, usd);
        let result = money1 - money2;
        assert!(approx_eq!(f64, result.as_f64(), 750.0, epsilon = 1e-9));
        assert_eq!(result.currency, usd);
    }

    #[rstest]
    fn test_money_checked_add_within_bounds() {
        let usd = Currency::USD();
        let a = Money::new(100.0, usd);
        let b = Money::new(50.0, usd);
        assert_eq!(a.checked_add(b), Some(Money::new(150.0, usd)));
    }

    #[rstest]
    fn test_money_checked_add_above_max_returns_none() {
        let usd = Currency::USD();
        let near_max = Money::from_raw(MONEY_RAW_MAX, usd);
        let one = Money::new(1.0, usd);
        assert_eq!(near_max.checked_add(one), None);
    }

    #[rstest]
    fn test_money_checked_sub_within_bounds() {
        let usd = Currency::USD();
        let a = Money::new(100.0, usd);
        let b = Money::new(40.0, usd);
        assert_eq!(a.checked_sub(b), Some(Money::new(60.0, usd)));
    }

    #[rstest]
    fn test_money_checked_sub_below_min_returns_none() {
        let usd = Currency::USD();
        let near_min = Money::from_raw(MONEY_RAW_MIN, usd);
        let one = Money::new(1.0, usd);
        assert_eq!(near_min.checked_sub(one), None);
    }

    #[rstest]
    fn test_money_checked_add_below_min_returns_none() {
        let usd = Currency::USD();
        let minus_one_unit = Money::from_raw(-1, usd);

        assert_eq!(
            Money::from_raw(MONEY_RAW_MIN, usd).checked_add(minus_one_unit),
            None
        );
        assert_eq!(
            Money::from_raw(MONEY_RAW_MIN + 1, usd).checked_add(minus_one_unit),
            Some(Money::from_raw(MONEY_RAW_MIN, usd))
        );
    }

    #[rstest]
    fn test_money_checked_sub_above_max_returns_none() {
        let usd = Currency::USD();
        let minus_one_unit = Money::from_raw(-1, usd);

        assert_eq!(
            Money::from_raw(MONEY_RAW_MAX, usd).checked_sub(minus_one_unit),
            None
        );
        assert_eq!(
            Money::from_raw(MONEY_RAW_MAX - 1, usd).checked_sub(minus_one_unit),
            Some(Money::from_raw(MONEY_RAW_MAX, usd))
        );
    }

    #[rstest]
    #[should_panic(expected = "Currency mismatch")]
    fn test_money_checked_add_currency_mismatch_panics() {
        let usd = Money::new(100.0, Currency::USD());
        let aud = Money::new(50.0, Currency::AUD());
        let _ = usd.checked_add(aud);
    }

    #[rstest]
    #[should_panic(expected = "Currency mismatch")]
    fn test_money_checked_sub_currency_mismatch_panics() {
        let usd = Money::new(100.0, Currency::USD());
        let aud = Money::new(50.0, Currency::AUD());
        let _ = usd.checked_sub(aud);
    }

    #[rstest]
    fn test_money_checked_add_at_exact_max_returns_some() {
        let usd = Currency::USD();
        let near_max = Money::from_raw(MONEY_RAW_MAX - 1, usd);
        let one_unit = Money::from_raw(1, usd);
        assert_eq!(
            near_max.checked_add(one_unit),
            Some(Money::from_raw(MONEY_RAW_MAX, usd)),
        );
    }

    #[rstest]
    fn test_money_checked_sub_at_exact_min_returns_some() {
        let usd = Currency::USD();
        let near_min = Money::from_raw(MONEY_RAW_MIN + 1, usd);
        let one_unit = Money::from_raw(1, usd);
        assert_eq!(
            near_min.checked_sub(one_unit),
            Some(Money::from_raw(MONEY_RAW_MIN, usd)),
        );
    }

    #[rstest]
    fn test_money_negation() {
        let money = Money::new(100.0, Currency::USD());
        let result = -money;
        assert_eq!(result, Money::from("-100.0 USD"));
        assert_eq!(result.currency, Currency::USD().clone());
    }

    #[rstest]
    fn test_money_addition_decimal() {
        let money = Money::new(100.0, Currency::USD());
        let result = money + dec!(50.25);
        assert_eq!(result, dec!(150.25));
    }

    #[rstest]
    fn test_money_subtraction_decimal() {
        let money = Money::new(100.0, Currency::USD());
        let result = money - dec!(30.50);
        assert_eq!(result, dec!(69.50));
    }

    #[rstest]
    fn test_money_multiplication_decimal() {
        let money = Money::new(100.0, Currency::USD());
        let result = money * dec!(1.5);
        assert_eq!(result, dec!(150.00));
    }

    #[rstest]
    fn test_money_division_decimal() {
        let money = Money::new(100.0, Currency::USD());
        let result = money / dec!(4);
        assert_eq!(result, dec!(25.00));
    }

    #[rstest]
    fn test_money_addition_f64() {
        let money = Money::new(100.0, Currency::USD());
        let result = money + 50.25;
        assert!(approx_eq!(f64, result, 150.25, epsilon = 1e-9));
    }

    #[rstest]
    fn test_money_subtraction_f64() {
        let money = Money::new(100.0, Currency::USD());
        let result = money - 30.50;
        assert!(approx_eq!(f64, result, 69.50, epsilon = 1e-9));
    }

    #[rstest]
    fn test_money_multiplication_f64() {
        let money = Money::new(100.0, Currency::USD());
        let result = money * 1.5;
        assert!(approx_eq!(f64, result, 150.0, epsilon = 1e-9));
    }

    #[rstest]
    fn test_money_division_f64() {
        let money = Money::new(100.0, Currency::USD());
        let result = money / 4.0;
        assert!(approx_eq!(f64, result, 25.0, epsilon = 1e-9));
    }

    #[rstest]
    fn test_money_new_usd() {
        let money = Money::new(1000.0, Currency::USD());
        assert_eq!(money.currency.code.as_str(), "USD");
        assert_eq!(money.currency.precision, 2);
        assert_eq!(money.to_string(), "1000.00 USD");
        assert_eq!(money.to_formatted_string(), "1_000.00 USD");
        assert_eq!(money.as_decimal(), dec!(1000.00));
        assert!(approx_eq!(f64, money.as_f64(), 1000.0, epsilon = 0.001));
    }

    #[rstest]
    fn test_money_new_btc() {
        let money = Money::new(10.3, Currency::BTC());
        assert_eq!(money.currency.code.as_str(), "BTC");
        assert_eq!(money.currency.precision, 8);
        assert_eq!(money.to_string(), "10.30000000 BTC");
        assert_eq!(money.to_formatted_string(), "10.30000000 BTC");
    }

    #[rstest]
    fn test_to_formatted_string_preserves_digits_beyond_f64_precision() {
        use crate::enums::CurrencyType;

        // 19 significant digits exceed f64's ~16-digit resolution; the previous
        // f64-based formatting printed the nearest float instead.
        let currency = Currency::new("TST9", 9, 0, "Test 9dp", CurrencyType::Crypto);
        let money = Money::from_decimal(dec!(1234567890.123456789), currency).unwrap();

        assert_eq!(money.to_formatted_string(), "1_234_567_890.123456789 TST9");
    }

    #[rstest]
    #[case("0USD")] // <-- No whitespace separator
    #[case("0x00 USD")] // <-- Invalid float
    #[case("0 US")] // <-- Invalid currency
    #[case("0 USD USD")] // <-- Too many parts
    #[should_panic(expected = "Condition failed")]
    fn test_from_str_invalid_input(#[case] input: &str) {
        let _ = Money::from(input);
    }

    #[rstest]
    #[case("invalid UNKNOWN_FROM_STR", "Unknown currency: UNKNOWN_FROM_STR")]
    #[case(
        "1__e+ USD",
        "Error parsing amount '1__e+' as Decimal: Failed to parse"
    )]
    fn test_from_str_preserves_error_order_and_input(#[case] input: &str, #[case] expected: &str) {
        assert_eq!(input.parse::<Money>(), Err(expected.to_string()));
    }

    #[rstest]
    #[case("0 USD", Currency::USD(), dec!(0.00))]
    #[case("1.1 AUD", Currency::AUD(), dec!(1.10))]
    #[case("1.12345678 BTC", Currency::BTC(), dec!(1.12345678))]
    #[case("10_000.10 USD", Currency::USD(), dec!(10000.10))]
    fn test_from_str_valid_input(
        #[case] input: &str,
        #[case] expected_currency: Currency,
        #[case] expected_dec: Decimal,
    ) {
        let money = Money::from(input);
        assert_eq!(money.currency, expected_currency);
        assert_eq!(money.as_decimal(), expected_dec);
    }

    #[rstest]
    #[case("1.005 USD", dec!(1.00))]
    #[case("1.015 USD", dec!(1.02))]
    #[case("-1.005 USD", dec!(-1.00))]
    #[case("-1.015 USD", dec!(-1.02))]
    fn test_from_str_rounds_half_to_even(#[case] input: &str, #[case] expected: Decimal) {
        let money = input.parse::<Money>().unwrap();

        assert_eq!(
            money,
            Money::from_decimal(expected, Currency::USD()).unwrap()
        );
        assert_eq!(money.currency, Currency::USD());
        assert_eq!(money.as_decimal(), expected);
    }

    #[rstest]
    fn test_money_from_str_negative() {
        let money = Money::from("-123.45 USD");
        assert!(approx_eq!(f64, money.as_f64(), -123.45, epsilon = 1e-9));
        assert_eq!(money.currency, Currency::USD());
    }

    #[rstest]
    #[case("1e7 USD", 10_000_000.0)]
    #[case("2.5e3 EUR", 2_500.0)]
    #[case("1.234e-2 GBP", 0.01)] // GBP has 2 decimal places, so 0.01234 becomes 0.01
    #[case("5E-3 JPY", 0.0)] // JPY has 0 decimal places, so 0.005 becomes 0
    fn test_from_str_scientific_notation(#[case] input: &str, #[case] expected_value: f64) {
        let money = Money::from_str(input).unwrap();
        assert!(approx_eq!(
            f64,
            money.as_f64(),
            expected_value,
            epsilon = 1e-10
        ));
    }

    #[rstest]
    #[case("1_234.56 USD", 1234.56)]
    #[case("1_000_000 EUR", 1_000_000.0)]
    #[case("99_999.99 GBP", 99_999.99)]
    fn test_from_str_with_underscores(#[case] input: &str, #[case] expected_value: f64) {
        let money = Money::from_str(input).unwrap();
        assert!(approx_eq!(
            f64,
            money.as_f64(),
            expected_value,
            epsilon = 1e-10
        ));
    }

    #[rstest]
    fn test_from_decimal_precision_preservation() {
        use rust_decimal::Decimal;

        let decimal = Decimal::from_str("123.45").unwrap();
        let money = Money::from_decimal(decimal, Currency::USD()).unwrap();
        assert_eq!(money.currency.precision, 2);
        assert!(approx_eq!(f64, money.as_f64(), 123.45, epsilon = 1e-10));

        // Verify raw value is exact for USD (2 decimal places)
        let expected_raw = 12345 * 10_i64.pow(u32::from(FIXED_PRECISION - 2));
        assert_eq!(money.raw, MoneyRaw::from(expected_raw));
    }

    #[rstest]
    fn test_from_decimal_rounding() {
        use rust_decimal::Decimal;

        // Test banker's rounding with USD (2 decimal places)
        let decimal = Decimal::from_str("1.005").unwrap();
        let money = Money::from_decimal(decimal, Currency::USD()).unwrap();
        assert_eq!(money.as_f64(), 1.0); // 1.005 rounds to 1.00 (even)

        let decimal = Decimal::from_str("1.015").unwrap();
        let money = Money::from_decimal(decimal, Currency::USD()).unwrap();
        assert_eq!(money.as_f64(), 1.02); // 1.015 rounds to 1.02 (even)
    }

    #[rstest]
    fn test_money_hash() {
        use std::{
            collections::hash_map::DefaultHasher,
            hash::{Hash, Hasher},
        };

        let m1 = Money::new(100.0, Currency::USD());
        let m2 = Money::new(100.0, Currency::USD());
        let m3 = Money::new(100.0, Currency::AUD());

        let mut s1 = DefaultHasher::new();
        let mut s2 = DefaultHasher::new();
        let mut s3 = DefaultHasher::new();

        m1.hash(&mut s1);
        m2.hash(&mut s2);
        m3.hash(&mut s3);

        assert_eq!(
            s1.finish(),
            s2.finish(),
            "Same amount + same currency => same hash"
        );
        assert_ne!(
            s1.finish(),
            s3.finish(),
            "Same amount + different currency => different hash"
        );
    }

    #[rstest]
    fn test_money_serialization_deserialization() {
        let money = Money::new(123.45, Currency::USD());
        let serialized = serde_json::to_string(&money);
        let deserialized: Money = serde_json::from_str(&serialized.unwrap()).unwrap();
        assert_eq!(money, deserialized);
    }

    #[rstest]
    fn test_money_deserialize_from_owned_value() {
        let money = Money::new(123.45, Currency::USD());
        let value = serde_json::to_value(money).unwrap();

        let deserialized: Money = serde_json::from_value(value).unwrap();
        assert_eq!(money, deserialized);
    }

    #[rstest]
    fn test_money_deserialize_invalid_format_returns_error() {
        let result = serde_json::from_str::<Money>("\"100.00\"");
        let error = result.unwrap_err();
        assert!(
            error.to_string().contains("Expected '<amount> <currency>'"),
            "unexpected message: {error}"
        );
    }

    #[rstest]
    fn test_money_deserialize_unknown_currency_returns_error() {
        let result = serde_json::from_str::<Money>("\"100.00 ZZZZ\"");
        let error = result.unwrap_err();
        assert!(
            error.to_string().contains("Unknown currency"),
            "unexpected message: {error}"
        );
    }

    #[rstest]
    #[should_panic(expected = "`raw` value")]
    fn test_money_from_raw_out_of_range_panics() {
        let usd = Currency::USD();
        let raw = MONEY_RAW_MAX.saturating_add(1);
        let _ = Money::from_raw(raw, usd);
    }

    #[rstest]
    fn test_money_from_raw_checked_valid() {
        let usd = Currency::USD();
        let money = Money::from_raw_checked(123_450_000_000, usd).unwrap();
        assert_eq!(money.currency, usd);
    }

    #[rstest]
    fn test_money_from_raw_checked_above_max_returns_error() {
        let usd = Currency::USD();
        let raw = MONEY_RAW_MAX.saturating_add(1);
        let error = Money::from_raw_checked(raw, usd).unwrap_err();
        assert!(matches!(error, CorrectnessError::PredicateViolation { .. }));
    }

    #[rstest]
    fn test_money_from_raw_checked_below_min_returns_error() {
        let usd = Currency::USD();
        let raw = MONEY_RAW_MIN.saturating_sub(1);
        let error = Money::from_raw_checked(raw, usd).unwrap_err();
        assert!(matches!(error, CorrectnessError::PredicateViolation { .. }));
    }

    #[rstest]
    fn test_from_decimal_rejects_out_of_range() {
        let huge = Decimal::from_str("99999999999999999999.99").unwrap();
        let result = Money::from_decimal(huge, Currency::USD());
        assert!(result.is_err());
    }

    #[rstest]
    fn test_from_decimal_rejects_raw_between_money_and_raw_bounds() {
        let usd = Currency::USD();
        let at_max = Decimal::try_from(MONEY_MAX).unwrap();
        let above_max = at_max + dec!(0.5);
        let expected_raw = MONEY_RAW_MAX + 5 * MoneyRaw::pow(10, u32::from(FIXED_PRECISION - 1));

        let error = Money::from_decimal(above_max, usd).unwrap_err();

        assert_eq!(
            error.to_string(),
            format!(
                "Raw value {expected_raw} exceeded bounds [{MONEY_RAW_MIN}, {MONEY_RAW_MAX}] for Money"
            )
        );
        assert_eq!(Money::from_decimal(at_max, usd).unwrap().raw, MONEY_RAW_MAX);
    }

    #[rstest]
    fn test_from_decimal_out_of_range_returns_typed_error_with_stable_display() {
        let huge = Decimal::from_str("99999999999999999999.99").unwrap();
        let error = Money::from_decimal(huge, Currency::USD()).unwrap_err();
        match error {
            CorrectnessError::PredicateViolation { ref message } => {
                assert!(
                    message.contains("MoneyRaw range") || message.contains("Money"),
                    "unexpected message: {message:?}",
                );
            }
            _ => panic!("expected PredicateViolation, was {error:?}"),
        }
    }

    #[rstest]
    fn test_from_mantissa_exponent_exact_precision() {
        let money = Money::from_mantissa_exponent(12345, -2, Currency::USD());
        assert_eq!(money.as_f64(), 123.45);
    }

    #[rstest]
    fn test_from_mantissa_exponent_excess_rounds_down() {
        // 12.345 rounds to 12.34 (4 is even, banker's rounding)
        let money = Money::from_mantissa_exponent(12345, -3, Currency::USD());
        assert_eq!(money.as_f64(), 12.34);
    }

    #[rstest]
    fn test_from_mantissa_exponent_excess_rounds_up() {
        // 12.355 rounds to 12.36 (5 is odd, banker's rounding)
        let money = Money::from_mantissa_exponent(12355, -3, Currency::USD());
        assert_eq!(money.as_f64(), 12.36);
    }

    #[rstest]
    fn test_from_mantissa_exponent_positive_exponent() {
        let money = Money::from_mantissa_exponent(5, 2, Currency::USD());
        assert_eq!(money.as_f64(), 500.0);
    }

    #[rstest]
    #[should_panic(expected = "Money::from_mantissa_exponent")]
    fn test_from_mantissa_exponent_overflow_panics() {
        let _ = Money::from_mantissa_exponent(i64::MAX, 9, Currency::USD());
    }

    #[rstest]
    #[should_panic(expected = "exceeds i128 range")]
    fn test_from_mantissa_exponent_large_exponent_panics() {
        let _ = Money::from_mantissa_exponent(1, 119, Currency::USD());
    }

    #[rstest]
    fn test_from_mantissa_exponent_zero_with_large_exponent() {
        let money = Money::from_mantissa_exponent(0, 119, Currency::USD());
        assert_eq!(money.as_f64(), 0.0);
    }

    #[rstest]
    fn test_from_mantissa_exponent_very_negative_exponent_rounds_to_zero() {
        // exponent=-120, frac_digits=120, excess=118 for USD (precision 2)
        let money = Money::from_mantissa_exponent(12345, -120, Currency::USD());
        assert_eq!(money.as_f64(), 0.0);
    }

    #[rstest]
    #[case(42.0, true, "positive value")]
    #[case(0.0, false, "zero value")]
    #[case( -13.5,  false, "negative value")]
    #[expect(
        clippy::used_underscore_binding,
        reason = "rstest case name documents the parameterized input"
    )]
    fn test_check_positive_money(
        #[case] amount: f64,
        #[case] should_succeed: bool,
        #[case] _case_name: &str,
    ) {
        let money = Money::new(amount, Currency::USD());

        let res = check_positive_money(money, "money");

        if should_succeed {
            assert!(res.is_ok(), "expected Ok(..) for {amount}");
        } else {
            assert!(res.is_err(), "expected Err(..) for {amount}");
            let msg = res.unwrap_err().to_string();
            assert!(
                msg.contains("not positive"),
                "error message should mention positivity; got: {msg:?}"
            );
        }
    }

    #[rstest]
    fn test_check_positive_money_returns_typed_error_with_stable_display() {
        let error = check_positive_money(Money::new(0.0, Currency::USD()), "money").unwrap_err();

        assert_eq!(
            error,
            CorrectnessError::NotPositive {
                param: "money".to_string(),
                value: "0.00 USD".to_string(),
                type_name: "`Money`",
            }
        );
        assert_eq!(
            error.to_string(),
            "invalid `Money` for 'money' not positive, was 0.00 USD"
        );
    }
}

#[cfg(test)]
mod property_tests {
    use proptest::prelude::*;
    use rstest::rstest;

    use super::*;

    fn currency_strategy() -> impl Strategy<Value = Currency> {
        prop_oneof![
            Just(Currency::USD()),
            Just(Currency::EUR()),
            Just(Currency::GBP()),
            Just(Currency::JPY()),
            Just(Currency::AUD()),
            Just(Currency::CAD()),
            Just(Currency::CHF()),
            Just(Currency::BTC()),
            Just(Currency::ETH()),
            Just(Currency::USDT()),
        ]
    }

    fn money_amount_strategy() -> impl Strategy<Value = f64> {
        prop_oneof![
            -1000.0..1000.0,
            -100_000.0..100_000.0,
            -1_000_000.0..1_000_000.0,
            Just(0.0),
            Just(MONEY_MIN / 2.0),
            Just(MONEY_MAX / 2.0),
            Just(MONEY_MIN + 1.0),
            Just(MONEY_MAX - 1.0),
            Just(MONEY_MIN),
            Just(MONEY_MAX),
        ]
    }

    fn money_strategy() -> impl Strategy<Value = Money> {
        (money_amount_strategy(), currency_strategy())
            .prop_filter_map("constructible money", |(amount, currency)| {
                Money::new_checked(amount, currency).ok()
            })
    }

    proptest! {
        #[rstest]
        fn prop_money_construction_roundtrip(
            amount in money_amount_strategy(),
            currency in currency_strategy()
        ) {
            if let Ok(money) = Money::new_checked(amount, currency) {
                let roundtrip = money.as_f64();
                let precision_epsilon = if currency.precision == 0 {
                    1.0
                } else {
                    let currency_epsilon = 10.0_f64.powi(-i32::from(currency.precision));
                    let magnitude_epsilon = amount.abs() * 1e-10;
                    currency_epsilon.max(magnitude_epsilon)
                };
                prop_assert!((roundtrip - amount).abs() <= precision_epsilon,
                    "Roundtrip failed: {} -> {} -> {} (precision: {}, epsilon: {})",
                    amount, money.raw, roundtrip, currency.precision, precision_epsilon);
                prop_assert_eq!(money.currency, currency);
            }
        }

        #[rstest]
        fn prop_money_addition_commutative(
            money1 in money_strategy(),
            money2 in money_strategy(),
        ) {
            if money1.currency == money2.currency
                && let (Some(_), Some(_)) = (
                    money1.raw.checked_add(money2.raw),
                    money2.raw.checked_add(money1.raw)
                )
            {
                let sum1 = money1 + money2;
                let sum2 = money2 + money1;
                prop_assert_eq!(sum1, sum2, "Addition should be commutative");
                prop_assert_eq!(sum1.currency, money1.currency);
            }
        }

        #[rstest]
        fn prop_money_addition_associative(
            money1 in money_strategy(),
            money2 in money_strategy(),
            money3 in money_strategy(),
        ) {
            if money1.currency == money2.currency
                && money2.currency == money3.currency
                && let (Some(sum1), Some(sum2)) = (
                    money1.raw.checked_add(money2.raw),
                    money2.raw.checked_add(money3.raw)
                )
                && let (Some(left), Some(right)) = (
                    sum1.checked_add(money3.raw),
                    money1.raw.checked_add(sum2)
                )
                && (MONEY_RAW_MIN..=MONEY_RAW_MAX).contains(&left)
                && (MONEY_RAW_MIN..=MONEY_RAW_MAX).contains(&right)
            {
                let left_result = Money::from_raw(left, money1.currency);
                let right_result = Money::from_raw(right, money1.currency);
                prop_assert_eq!(left_result, right_result, "Addition should be associative");
            }
        }

        #[rstest]
        fn prop_money_subtraction_inverse(
            money1 in money_strategy(),
            money2 in money_strategy(),
        ) {
            if money1.currency == money2.currency
                && let Some(sum_raw) = money1.raw.checked_add(money2.raw)
                && (MONEY_RAW_MIN..=MONEY_RAW_MAX).contains(&sum_raw)
            {
                let sum = Money::from_raw(sum_raw, money1.currency);
                let diff = sum - money2;
                prop_assert_eq!(diff, money1, "Subtraction should be inverse of addition");
            }
        }

        /// Property: checked_add agrees with raw checked_add when result is in bounds and
        /// currencies match; returns None when out of bounds.
        #[rstest]
        fn prop_money_checked_add_matches_spec(
            raw1 in MONEY_RAW_MIN..=MONEY_RAW_MAX,
            raw2 in MONEY_RAW_MIN..=MONEY_RAW_MAX,
            currency in currency_strategy(),
        ) {
            let m1 = Money::from_raw(raw1, currency);
            let m2 = Money::from_raw(raw2, currency);
            let expected = m1.raw
                .checked_add(m2.raw)
                .filter(|r| (MONEY_RAW_MIN..=MONEY_RAW_MAX).contains(r))
                .map(|raw| Money { raw, currency });
            prop_assert_eq!(m1.checked_add(m2), expected);
        }

        /// Property: checked_sub agrees with raw checked_sub when result is in bounds and
        /// currencies match; returns None when out of bounds.
        #[rstest]
        fn prop_money_checked_sub_matches_spec(
            raw1 in MONEY_RAW_MIN..=MONEY_RAW_MAX,
            raw2 in MONEY_RAW_MIN..=MONEY_RAW_MAX,
            currency in currency_strategy(),
        ) {
            let m1 = Money::from_raw(raw1, currency);
            let m2 = Money::from_raw(raw2, currency);
            let expected = m1.raw
                .checked_sub(m2.raw)
                .filter(|r| (MONEY_RAW_MIN..=MONEY_RAW_MAX).contains(r))
                .map(|raw| Money { raw, currency });
            prop_assert_eq!(m1.checked_sub(m2), expected);
        }

        #[rstest]
        fn prop_money_zero_identity(money in money_strategy()) {
            let zero = Money::zero(money.currency);
            prop_assert_eq!(money + zero, money, "Zero should be additive identity");
            prop_assert_eq!(zero + money, money, "Zero should be additive identity (commutative)");
            prop_assert!(zero.is_zero(), "Zero should be recognized as zero");
        }

        #[rstest]
        fn prop_money_negation_inverse(money in money_strategy()) {
            let negated = -money;
            let double_neg = -negated;
            prop_assert_eq!(money, double_neg, "Double negation should equal original");
            prop_assert_eq!(negated.currency, money.currency, "Negation preserves currency");

            if let Some(sum_raw) = money.raw.checked_add(negated.raw)
                && (MONEY_RAW_MIN..=MONEY_RAW_MAX).contains(&sum_raw) {
                    let sum = Money::from_raw(sum_raw, money.currency);
                    prop_assert!(sum.is_zero(), "Money + (-Money) should equal zero");
                }
        }

        #[rstest]
        fn prop_money_comparison_consistency(
            money1 in money_strategy(),
            money2 in money_strategy(),
        ) {
            let eq = money1 == money2;
            let lt = money1 < money2;
            let gt = money1 > money2;
            let le = money1 <= money2;
            let ge = money1 >= money2;

            let exclusive_count = [eq, lt, gt].iter().filter(|&&x| x).count();
            prop_assert_eq!(exclusive_count, 1, "Exactly one of ==, <, > should be true");

            prop_assert_eq!(le, eq || lt, "<= should equal == || <");
            prop_assert_eq!(ge, eq || gt, ">= should equal == || >");
            prop_assert_eq!(lt, money2 > money1, "< should be symmetric with >");
            prop_assert_eq!(le, money2 >= money1, "<= should be symmetric with >=");
        }

        #[rstest]
        fn prop_money_decimal_conversion(money in money_strategy()) {
            let decimal = money.as_decimal();

            // Scale must always match currency precision
            prop_assert_eq!(decimal.scale(), u32::from(money.currency.precision));

            #[cfg(feature = "defi")]
            {
                let decimal_f64: f64 = decimal.try_into().unwrap_or(0.0);
                prop_assert!(decimal_f64.is_finite(), "Decimal should convert to finite f64");
            }
            #[cfg(not(feature = "defi"))]
            {
                let decimal_f64: f64 = decimal.try_into().unwrap_or(0.0);
                let original_f64 = money.as_f64();

                let base_epsilon = 10.0_f64.powi(-i32::from(money.currency.precision));
                let precision_epsilon = if cfg!(feature = "high-precision") {
                    base_epsilon.max(1e-10)
                } else {
                    base_epsilon
                };
                let diff = (decimal_f64 - original_f64).abs();
                prop_assert!(diff <= precision_epsilon,
                    "Decimal conversion should preserve value within currency precision: {} vs {} (diff: {}, epsilon: {})",
                    original_f64, decimal_f64, diff, precision_epsilon);
            }
        }

        #[rstest]
        fn prop_money_arithmetic_with_f64(
            money in money_strategy(),
            factor in -1000.0..1000.0_f64,
        ) {
            if factor != 0.0 {
                let original_f64 = money.as_f64();

                let mul_result = money * factor;
                let expected_mul = original_f64 * factor;
                prop_assert!((mul_result - expected_mul).abs() < 0.01,
                    "Multiplication with f64 should be accurate");

                let div_result = money / factor;
                let expected_div = original_f64 / factor;
                if expected_div.is_finite() {
                    prop_assert!((div_result - expected_div).abs() < 0.01,
                        "Division with f64 should be accurate");
                }

                let add_result = money + factor;
                let expected_add = original_f64 + factor;
                prop_assert!((add_result - expected_add).abs() < 0.01,
                    "Addition with f64 should be accurate");

                let sub_result = money - factor;
                let expected_sub = original_f64 - factor;
                prop_assert!((sub_result - expected_sub).abs() < 0.01,
                    "Subtraction with f64 should be accurate");
            }
        }
    }
}