Enum Denomination 

#[non_exhaustive]
pub enum Denomination {
    Bitcoin,
    CentiBitcoin,
    MilliBitcoin,
    MicroBitcoin,
    Bit,
    Satoshi,
}

A set of denominations in which amounts can be expressed.

Accepted Denominations

All upper or lower case, excluding SI prefixes c, m and u (or µ) which must be lower case.

• Singular: BTC, cBTC, mBTC, uBTC
• Plural or singular: sat, satoshi, bit

Note

Due to ambiguity between mega and milli we prohibit usage of leading capital ‘M’. It is more important to protect users from incorrectly using a capital M to mean milli than to allow Megabitcoin which is not a realistic denomination, and Megasatoshi which is equivalent to cBTC which is allowed.

Examples

let equal = [
    ("1 BTC", 100_000_000),
    ("1 cBTC", 1_000_000),
    ("1 mBTC", 100_000),
    ("1 uBTC", 100),
    ("1 bit", 100),
    ("1 sat", 1),
];
for (string, sats) in equal {
    assert_eq!(
        string.parse::<Amount>().expect("valid bitcoin amount string"),
        Amount::from_sat(sats)?,
    )
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Bitcoin

BTC (1 BTC = 100,000,000 satoshi).

CentiBitcoin

cBTC (1 cBTC = 1,000,000 satoshi).

MilliBitcoin

mBTC (1 mBTC = 100,000 satoshi).

MicroBitcoin

µBTC (1 µBTC = 100 satoshi).

Bit

bits (bits = µBTC).

Satoshi

satoshi (1 BTC = 100,000,000 satoshi).

Implementations

impl Denomination

pub const BTC: Denomination = Self::Bitcoin

Convenience alias for Denomination::Bitcoin.

pub const SAT: Denomination = Self::Satoshi

Convenience alias for Denomination::Satoshi.

Trait Implementations

impl<'a> Arbitrary<'a> for Denomination

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Denomination, Error>

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.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

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

impl Clone for Denomination

fn clone(&self) -> Denomination

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Denomination

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

Formats the value using the given formatter.

impl Display for Denomination

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

Formats the value using the given formatter.

impl FromStr for Denomination

fn from_str(s: &str) -> Result<Denomination, <Denomination as FromStr>::Err>

Converts from a str to a Denomination.

Errors

• ParseDenominationError::PossiblyConfusing: If the denomination begins with a capital letter that could be confused with centi, milli, or micro-bitcoin.
• ParseDenominationError::Unknown: If an unknown denomination is used.

type Err = ParseDenominationError

The associated error which can be returned from parsing.

impl Hash for Denomination

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

where __H: Hasher,

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 PartialEq for Denomination

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

impl Eq for Denomination

impl StructuralPartialEq for Denomination