Enum BalanceVariant 

pub enum BalanceVariant<Balance> {
    Default(Balance),
    Denominated(DenominatedBalance),
}

Represents different formats of a balance

Variants

Default(Balance)

Default format: no symbol, no token_decimals

Denominated(DenominatedBalance)

Denominated format: symbol and token_decimals are present

Implementations

impl<Balance> BalanceVariant<Balance>

where Balance: From<u128> + Clone,

pub fn denominate_balance( &self, token_metadata: &TokenMetadata, ) -> Result<Balance>

Converts BalanceVariant into Balance.

It is a reverse process of from<T: Into<u128>>()

Throws Error if value is of nigher precision that allowed.

use contract_extrinsics::{
    BalanceVariant,
    TokenMetadata,
};
let decimals = 6;
let tm = TokenMetadata {
    token_decimals: decimals,
    symbol: String::from("DOT"),
};
let sample_den_balance: BalanceVariant<u128> = "0.4\u{3bc}DOT".parse().unwrap();
let result = sample_den_balance.denominate_balance(&tm);
assert!(result.is_err());

Otherwise, [Balance] is returned:

use contract_extrinsics::{
    BalanceVariant,
    TokenMetadata,
};
let decimals = 6;
let tm = TokenMetadata {
    token_decimals: decimals,
    symbol: String::from("DOT"),
};
let sample_den_balance: BalanceVariant<u128> = "4123\u{3bc}DOT".parse().unwrap();
let balance = 4123;
let result = sample_den_balance.denominate_balance(&tm).unwrap();
assert_eq!(balance, result);

pub fn from<T: Into<u128>>( value: T, token_metadata: Option<&TokenMetadata>, ) -> Result<Self>

Summary

Display token units in a denominated format.

I takes value of Into<u128> and TokenMetadata and calculates the value in an denominated format by manipulating the token_decimals.

If the number is divisible by 10^(token_decimals + unit_zeros), It sets the UnitPrefix and divides the value into Decimal

If no TokenMetadata was present, than that means that [Balance] is to be displayed in normal format and BalanceVariant::Default is returned

Examples

use contract_extrinsics::{
    BalanceVariant,
    TokenMetadata,
};
let decimals = 10;
let tm = TokenMetadata {
    token_decimals: decimals,
    symbol: String::from("DOT"),
};
let sample_den_balance: BalanceVariant<u128> = "500.5MDOT".parse().unwrap();
let balance: u128 = 5_005_000_000_000_000_000;
let den_balance = BalanceVariant::from(balance, Some(&tm)).unwrap();
assert_eq!(sample_den_balance, den_balance);

Trait Implementations

impl<Balance: Clone> Clone for BalanceVariant<Balance>

fn clone(&self) -> BalanceVariant<Balance>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Balance: Debug> Debug for BalanceVariant<Balance>

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

Formats the value using the given formatter.

impl<Balance> Display for BalanceVariant<Balance>

where Balance: Display + Clone,

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

Formats the value using the given formatter.

impl<Balance> FromStr for BalanceVariant<Balance>

where Balance: FromStr,

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

Attempts to parse the balance either in plain or denominated formats If the balance is provide without the token symbol, then it is treated as raw. Otherwise, the balance is attempted to be parsed in a denominated format

type Err = Error

The associated error which can be returned from parsing.

impl<Balance: PartialEq> PartialEq for BalanceVariant<Balance>

fn eq(&self, other: &BalanceVariant<Balance>) -> 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<Balance: Eq> Eq for BalanceVariant<Balance>

impl<Balance> StructuralPartialEq for BalanceVariant<Balance>