Struct MonetaryValue

pub struct MonetaryValue {
    pub currency: CurrencyCode,
    pub value: i128,
}

MonetaryValues is a struct that paris a CurrencyCode with a value. This structure is able to represent both positive and negative currencies.

Fields

currency: CurrencyCode

value: i128

Implementations

impl MonetaryValue

pub fn new(currency: CurrencyCode, value: i128) -> Self

new creates a new MonetaryValue instance with the given CurrencyCode and i128 value.

pub fn usd(value: i128) -> Self

usd is a convenience function to create a MonetaryValue with the USD currency code.

pub fn btc(value: i128) -> Self

btc is a convenience function to create a MonetaryValue with the BTC currency code.

pub fn eth(value: i128) -> Self

eth is a convenience function to create a MonetaryValue with the ETH currency code.

pub fn esp(value: i128) -> Self

esp is a convenience function to create a MonetaryValue with the ESP currency code.

This is used to represents Espresso Tokens, and is the default that is used for Espresso Fees and Rewards

Trait Implementations

impl Add for MonetaryValue

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

add attempts to add the two MonetaryValues together. This returns a Result because this addition can fail if the two MonetaryValues do not have the same CurrencyCode.

type Output = Result<MonetaryValue, CurrencyMismatchError>

The resulting type after applying the + operator.

impl Clone for MonetaryValue

fn clone(&self) -> MonetaryValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MonetaryValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MonetaryValue

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

where D: Deserializer<'de>,

deserialize attempts to convert a string into a MonetaryValue.

impl Display for MonetaryValue

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

fmt formats the MonetaryValue into a human readable string. There’s no official standard for formatting a MonetaryValue into a string, but there are highly utilized cases that we can use as a reference to inform our implementation.

In referencing ISO 4217 we encounter a section titled Code position in amount formatting which references a style guide provided by the European Union’s Publication office which indicates that the value should be prefixed with the CurrencyCode, followed by a “hard space” (non-breaking space) and then the value of the currency itself. It also lists several countries which swaps the position of the currency code and the value.

In this case, we opt to use the European Union’s style guide, as it is at least backed by some form of standardization.

impl From<i128> for MonetaryValue

fn from(value: i128) -> Self

from converts an i128 into a MonetaryValue with the USD currency code.

impl PartialEq for MonetaryValue

fn eq(&self, other: &MonetaryValue) -> 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 Serialize for MonetaryValue

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

where S: Serializer,

serialize converts the MonetaryValue into a String representation.

impl Sub for MonetaryValue

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

sub attempts to subtract the two MonetaryValues together. This returns a Result because this subtraction can fail if the two MonetaryValues do not have the same CurrencyCode.

type Output = Result<MonetaryValue, CurrencyMismatchError>

The resulting type after applying the - operator.

impl Eq for MonetaryValue

impl StructuralPartialEq for MonetaryValue