Struct Money 

#[repr(C)]
pub struct Money {
    pub raw: MoneyRaw,
    pub currency: Currency,
}

Represents an amount of money in a specified currency denomination.

• MONEY_MAX - Maximum representable money amount
• MONEY_MIN - Minimum representable money amount

Fields

raw: MoneyRaw

Represents the raw fixed-point amount, with currency.precision defining the number of decimal places.

currency: Currency

The currency denomination associated with the monetary amount.

Implementations

impl Money

pub fn new_checked(amount: f64, currency: Currency) -> CorrectnessResult<Self>

Creates a new Money instance with correctness checking.

Errors

Returns an error if amount is invalid outside the representable range [MONEY_MIN, MONEY_MAX].

Notes

PyO3 requires a Result type for proper error handling and stacktrace printing in Python.

pub fn new(amount: f64, currency: Currency) -> Self

Creates a new Money instance.

Panics

Panics if a correctness check fails. See Money::new_checked for more details.

pub fn from_raw(raw: MoneyRaw, currency: Currency) -> Self

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.

pub fn from_raw_checked( raw: MoneyRaw, currency: Currency, ) -> CorrectnessResult<Self>

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_mantissa_exponent( mantissa: i64, exponent: i8, currency: Currency, ) -> Self

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.

pub fn zero(currency: Currency) -> Self

Creates a new Money instance with a value of zero with the given Currency.

Panics

Panics if a correctness check fails. See Money::new_checked for more details.

pub fn normalized(&self) -> Self

Returns a copy with raw value rounded to currency precision, stripping any sub-scale bits.

pub fn is_zero(&self) -> bool

Returns true if the value of this instance is zero.

pub fn is_positive(&self) -> bool

Returns true if the value of this instance is positive (> 0).

pub fn checked_add(self, rhs: Self) -> Option<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).

pub fn checked_sub(self, rhs: Self) -> Option<Self>

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).

pub fn as_f64(&self) -> f64

Returns the value of this instance as an f64.

Panics

Panics if precision is beyond MAX_FLOAT_PRECISION (16).

pub fn as_decimal(&self) -> Decimal

Returns the value of this instance as a Decimal.

pub fn to_formatted_string(&self) -> String

Returns a formatted string representation of this instance.

pub fn from_decimal( decimal: Decimal, currency: Currency, ) -> CorrectnessResult<Self>

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.

impl Money

pub fn from_wei<U>(raw_wei: U, currency: Currency) -> Self

where U: Into<U256>,

Creates a new Money instance from raw wei value with 18-decimal precision.

This method is specifically designed for DeFi applications where values are represented in wei (the smallest unit of Ether, 1 ETH = 10^18 wei).

Panics

Panics if currency.precision is not 18, or if the raw wei value exceeds the signed 128-bit range.

pub fn to_wei(&self) -> U256

Converts this Money instance to raw wei value.

Panics

Panics if self.currency.precision is not 18 or self.raw is negative. For other precisions convert to precision 18 first.

Trait Implementations

impl Add<Decimal> for Money

type Output = Decimal

The resulting type after applying the + operator.

fn add(self, rhs: Decimal) -> Self::Output

Performs the + operation.

impl Add<f64> for Money

type Output = f64

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl Add for Money

type Output = Money

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl Clone for Money

fn clone(&self) -> Money

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Money

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Money

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Money

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Div<Decimal> for Money

type Output = Decimal

The resulting type after applying the / operator.

fn div(self, rhs: Decimal) -> Self::Output

Performs the / operation.

impl Div<f64> for Money

type Output = f64

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl From<&Money> for f64

fn from(money: &Money) -> Self

Converts to this type from the input type.

impl From<Money> for f64

fn from(money: Money) -> Self

Converts to this type from the input type.

impl<T: AsRef<str>> From<T> for Money

fn from(value: T) -> Self

Converts to this type from the input type.

impl<'a, 'py> FromPyObject<'a, 'py> for Money

where Self: Clone,

type Error = PyClassGuardError<'a, 'py>

The type returned in the event of a conversion error.

fn extract( obj: Borrowed<'a, 'py, PyAny>, ) -> Result<Self, <Self as FromPyObject<'a, 'py>>::Error>

Extracts Self from the bound smart pointer obj.

impl FromStr for Money

type Err = String

The associated error which can be returned from parsing.

fn from_str(value: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Money

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'py> IntoPyObject<'py> for Money

type Target = Money

The Python output type

type Output = Bound<'py, <Money as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl Mul<Decimal> for Money

type Output = Decimal

The resulting type after applying the * operator.

fn mul(self, rhs: Decimal) -> Self::Output

Performs the * operation.

impl Mul<f64> for Money

type Output = f64

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl Neg for Money

type Output = Money

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for Money

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Money

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Money

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Self) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Self) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Self) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Self) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PyClass for Money

const NAME: &str = "Money"

Name of the class.

type Frozen = True

Whether the pyclass is frozen.

impl PyClassImpl for Money

const MODULE: Option<&str>

Module which the class will be associated with.

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// Represents an amount of money in a specified currency denomination. /// /// - [`MONEY_MAX`] - Maximum representable money amount /// - [`MONEY_MIN`] - Minimum representable money amount

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type Layout = <<Money as PyClassImpl>::BaseNativeType as PyClassBaseType>::Layout<Money>

Description of how this class is laid out in memory

type BaseType = PyAny

Base class

type ThreadChecker = NoopThreadChecker

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForMoney

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::ImmutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<PyObjectOffset>

Used to provide the dictoffset slot (equivalent to tp_dictoffset)

fn weaklist_offset() -> Option<PyObjectOffset>

Used to provide the weaklistoffset slot (equivalent to tp_weaklistoffset

impl PyClassNewTextSignature for Money

const TEXT_SIGNATURE: &'static str = "(amount, currency)"

impl PyClass__add__SlotFragment<Money> for PyClassImplCollector<Money>

unsafe fn __add__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__floordiv__SlotFragment<Money> for PyClassImplCollector<Money>

unsafe fn __floordiv__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__mod__SlotFragment<Money> for PyClassImplCollector<Money>

unsafe fn __mod__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__mul__SlotFragment<Money> for PyClassImplCollector<Money>

unsafe fn __mul__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__radd__SlotFragment<Money> for PyClassImplCollector<Money>

unsafe fn __radd__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__rfloordiv__SlotFragment<Money> for PyClassImplCollector<Money>

unsafe fn __rfloordiv__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__rmod__SlotFragment<Money> for PyClassImplCollector<Money>

unsafe fn __rmod__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__rmul__SlotFragment<Money> for PyClassImplCollector<Money>

unsafe fn __rmul__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__rsub__SlotFragment<Money> for PyClassImplCollector<Money>

unsafe fn __rsub__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__rtruediv__SlotFragment<Money> for PyClassImplCollector<Money>

unsafe fn __rtruediv__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__sub__SlotFragment<Money> for PyClassImplCollector<Money>

unsafe fn __sub__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyClass__truediv__SlotFragment<Money> for PyClassImplCollector<Money>

unsafe fn __truediv__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyStubType for Money

fn type_output() -> TypeInfo

The type to be used in the output signature, i.e. return type of the Python function or methods.

fn type_input() -> TypeInfo

The type to be used in the input signature, i.e. the arguments of the Python function or methods.

impl PyTypeInfo for Money

const NAME: &str = <Self as ::pyo3::PyClass>::NAME

👎Deprecated since 0.28.0:

prefer using ::type_object(py).name() to get the correct runtime value

Class name.

const MODULE: Option<&str> = <Self as ::pyo3::impl_::pyclass::PyClassImpl>::MODULE

👎Deprecated since 0.28.0:

prefer using ::type_object(py).module() to get the correct runtime value

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl Serialize for Money

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<Decimal> for Money

type Output = Decimal

The resulting type after applying the - operator.

fn sub(self, rhs: Decimal) -> Self::Output

Performs the - operation.

impl Sub<f64> for Money

type Output = f64

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl Sub for Money

type Output = Money

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl Copy for Money

impl DerefToPyAny for Money

impl Eq for Money