Struct Amount

pub struct Amount(/* private fields */);

An amount.

The Amount type can be used to express Bitcoin amounts that support arithmetic and conversion to various denominations.

Warning!

This type implements several arithmetic operations from core::ops. To prevent errors due to overflow or underflow when using these operations, it is advised to instead use the checked arithmetic methods whose names start with checked_. The operations from core::ops that Amount implements will panic when overflow or underflow occurs. Also note that since the internal representation of amounts is unsigned, subtracting below zero is considered an underflow and will cause a panic if you’re not using the checked arithmetic methods.

Implementations

impl Amount

pub const ZERO: Amount = _

The zero amount.

pub const ONE_SAT: Amount = _

Exactly one satoshi.

pub const ONE_BTC: Amount = _

Exactly one bitcoin.

pub const MAX_MONEY: Amount = _

The maximum value allowed as an amount. Useful for sanity checking.

pub const MIN: Amount = Amount::ZERO

The minimum value of an amount.

pub const MAX: Amount = _

The maximum value of an amount.

pub const SIZE: usize = 8usize

The number of bytes that an amount contributes to the size of a transaction.

pub const fn from_sat(satoshi: u64) -> Amount

Creates an Amount with satoshi precision and the given number of satoshis.

pub fn to_sat(self) -> u64

Gets the number of satoshis in this Amount.

pub fn from_btc(btc: f64) -> Result<Amount, ParseAmountError>

Available on crate feature alloc only.

Converts from a value expressing bitcoins to an Amount.

pub const fn from_int_btc(btc: u64) -> Amount

Converts from a value expressing integer values of bitcoins to an Amount in const context.

Panics

The function panics if the argument multiplied by the number of sats per bitcoin overflows a u64 type.

pub fn from_str_in( s: &str, denom: Denomination, ) -> Result<Amount, ParseAmountError>

Parses a decimal string as a value in the given denomination.

Note: This only parses the value string. If you want to parse a value with denomination, use FromStr.

pub fn from_str_with_denomination(s: &str) -> Result<Amount, ParseError>

Parses amounts with denomination suffix like they are produced with Self::to_string_with_denomination or with fmt::Display. If you want to parse only the amount without the denomination, use Self::from_str_in.

pub fn to_float_in(self, denom: Denomination) -> f64

Available on crate feature alloc only.

Expresses this Amount as a floating-point value in the given denomination.

Please be aware of the risk of using floating-point numbers.

pub fn to_btc(self) -> f64

Available on crate feature alloc only.

Expresses this Amount as a floating-point value in Bitcoin.

Please be aware of the risk of using floating-point numbers.

Examples

let amount = Amount::from_sat(100_000);
assert_eq!(amount.to_btc(), amount.to_float_in(Denomination::Bitcoin))

pub fn from_float_in( value: f64, denom: Denomination, ) -> Result<Amount, ParseAmountError>

Available on crate feature alloc only.

Converts this Amount in floating-point notation with a given denomination.

Errors

If the amount is too big, too precise or negative.

Please be aware of the risk of using floating-point numbers.

pub fn display_in(self, denomination: Denomination) -> Display

Creates an object that implements fmt::Display using specified denomination.

pub fn display_dynamic(self) -> Display

Creates an object that implements fmt::Display dynamically selecting denomination.

This will use BTC for values greater than or equal to 1 BTC and satoshis otherwise. To avoid confusion the denomination is always shown.

pub fn fmt_value_in(self, f: &mut dyn Write, denom: Denomination) -> Result

👎Deprecating in a future version: Use display_in() instead

Formats the value of this Amount in the given denomination.

Does not include the denomination.

pub fn to_string_in(self, denom: Denomination) -> String

Available on crate feature alloc only.

Returns a formatted string of this Amount in the given denomination.

Does not include the denomination.

pub fn to_string_with_denomination(self, denom: Denomination) -> String

Available on crate feature alloc only.

Returns a formatted string of this Amount in the given denomination, suffixed with the abbreviation for the denomination.

pub fn checked_add(self, rhs: Amount) -> Option<Amount>

Checked addition.

Returns None if overflow occurred.

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

Checked subtraction.

Returns None if overflow occurred.

pub fn checked_mul(self, rhs: u64) -> Option<Amount>

Checked multiplication.

Returns None if overflow occurred.

pub fn checked_div(self, rhs: u64) -> Option<Amount>

Checked integer division.

Be aware that integer division loses the remainder if no exact division can be made. Returns None if overflow occurred.

pub fn checked_rem(self, rhs: u64) -> Option<Amount>

Checked remainder.

Returns None if overflow occurred.

pub fn unchecked_add(self, rhs: Amount) -> Amount

Unchecked addition.

Computes self + rhs.

Panics

On overflow, panics in debug mode, wraps in release mode.

pub fn unchecked_sub(self, rhs: Amount) -> Amount

Unchecked subtraction.

Computes self - rhs.

Panics

On overflow, panics in debug mode, wraps in release mode.

pub fn to_signed(self) -> Result<SignedAmount, OutOfRangeError>

Converts to a signed amount.

Trait Implementations

impl Add for Amount

type Output = Amount

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Amount

fn add_assign(&mut self, other: Amount)

Performs the += operation.

impl<'a> Arbitrary<'a> for Amount

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<T> CheckedSum<Amount> for T

where T: Iterator<Item = Amount>,

fn checked_sum(self) -> Option<Amount>

Calculates the sum over the iterator using checked arithmetic. If an over or underflow would happen it returns None.

impl Clone for Amount

fn clone(&self) -> Amount

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Amount

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

Formats the value using the given formatter.

impl Default for Amount

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Amount

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Amount

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

Formats the value using the given formatter.

impl Div<Weight> for Amount

Available on crate feature alloc only.

type Output = FeeRate

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<u64> for Amount

type Output = Amount

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<u64> for Amount

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl FromStr for Amount

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

Parses a string slice where the slice includes a denomination.

If the string slice is zero, then no denomination is required.

Returns

Ok(Amount) if the string amount and denomination parse successfully, otherwise, return Err(ParseError).

type Err = ParseError

The associated error which can be returned from parsing.

impl Hash for Amount

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 Mul<u64> for Amount

type Output = Amount

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<u64> for Amount

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl Ord for Amount

fn cmp(&self, other: &Amount) -> 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 Amount

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

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

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

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

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

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

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

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

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

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

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

impl Rem<u64> for Amount

type Output = Amount

The resulting type after applying the % operator.

fn rem(self, modulus: u64) -> Self

Performs the % operation.

impl RemAssign<u64> for Amount

fn rem_assign(&mut self, modulus: u64)

Performs the %= operation.

impl SerdeAmount for Amount

Available on crate feature serde only.

fn ser_sat<S: Serializer>(self, s: S, _: Token) -> Result<S::Ok, S::Error>

fn des_sat<'d, D: Deserializer<'d>>(d: D, _: Token) -> Result<Self, D::Error>

fn ser_btc<S: Serializer>(self, s: S, _: Token) -> Result<S::Ok, S::Error>

Available on crate feature alloc only.

fn des_btc<'d, D: Deserializer<'d>>(d: D, _: Token) -> Result<Self, D::Error>

Available on crate feature alloc only.

impl SerdeAmountForOpt for Amount

Available on crate feature serde only.

fn type_prefix(_: Token) -> &'static str

fn ser_sat_opt<S: Serializer>(self, s: S, _: Token) -> Result<S::Ok, S::Error>

fn ser_btc_opt<S: Serializer>(self, s: S, _: Token) -> Result<S::Ok, S::Error>

Available on crate feature alloc only.

impl Serialize for Amount

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for Amount

type Output = Amount

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Amount

fn sub_assign(&mut self, other: Amount)

Performs the -= operation.

impl Sum for Amount

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl TryFrom<Amount> for SignedAmount

type Error = OutOfRangeError

The type returned in the event of a conversion error.

fn try_from(value: Amount) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<SignedAmount> for Amount

type Error = OutOfRangeError

The type returned in the event of a conversion error.

fn try_from(value: SignedAmount) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Amount

impl Eq for Amount

impl StructuralPartialEq for Amount