Struct FTBalance 

pub struct FTBalance {
    amount: u128,
    decimals: u8,
    symbol: &'static str,
}

A helper type that represents the fungible token balance with a given precision.

The type is created to simplify the usage of fungible tokens in similar way as the NearToken type does.

The symbol is used only for display purposes.

The type has static instances for some of the most popular tokens with correct decimals and symbol.

• USDT_BALANCE - USDT token with 6 decimals
• USDC_BALANCE - USDC token with 6 decimals
• W_NEAR_BALANCE - wNEAR token with 24 decimals

Examples

Defining 2.5 USDT

use near_api_types::tokens::FTBalance;

let usdt_balance = FTBalance::with_decimals(6).with_float_str("2.5").unwrap();

assert_eq!(usdt_balance.amount(), 2_500_000);

Defining 3 USDT using smaller precision

use near_api_types::tokens::FTBalance;

let usdt = FTBalance::with_decimals(6);

let usdt_balance = usdt.with_amount(3 * 10u128.pow(6));

assert_eq!(usdt_balance, usdt.with_whole_amount(3));

Defining 3 wETH using 18 decimals

use near_api_types::tokens::FTBalance;

let weth = FTBalance::with_decimals_and_symbol(18, "wETH");
let weth_balance = weth.with_whole_amount(3);

assert_eq!(weth_balance, weth.with_amount(3 * 10u128.pow(18)));

Fields

amount: u128

decimals: u8

symbol: &'static str

Implementations

impl FTBalance

pub const fn with_decimals(decimals: u8) -> FTBalance

Creates a new FTBalance with a given precision.

The balance is initialized to 0.

pub const fn with_decimals_and_symbol( decimals: u8, symbol: &'static str, ) -> FTBalance

Creates a new FTBalance with a given precision and symbol.

The balance is initialized to 0.

pub const fn with_amount(&self, amount: u128) -> FTBalance

Stores the given amount without any transformations.

The NearToken equivalent to this method is NearToken::from_yoctonear.

Example

use near_api_types::tokens::FTBalance;

let usdt_balance = FTBalance::with_decimals(6).with_amount(2_500_000);
assert_eq!(usdt_balance.amount(), 2_500_000);
assert_eq!(usdt_balance.to_whole(), 2);

pub const fn with_whole_amount(&self, amount: u128) -> FTBalance

Stores the number as an integer token value utilizing the given precision.

The NearToken equivalent to this method is NearToken::from_near.

Example

use near_api_types::tokens::FTBalance;

let usdt_balance = FTBalance::with_decimals(6).with_whole_amount(3);
assert_eq!(usdt_balance.amount(), 3 * 10u128.pow(6));
assert_eq!(usdt_balance.to_whole(), 3);

pub fn with_float_str( &self, float_str: &str, ) -> Result<FTBalance, DecimalNumberParsingError>

Parses float string and stores the value in defined precision.

Examples

Defining 2.5 USDT

use near_api_types::tokens::FTBalance;

let usdt_balance = FTBalance::with_decimals(6).with_float_str("2.515").unwrap();

assert_eq!(usdt_balance.amount(), 2_515_000);

pub const fn amount(&self) -> u128

Returns the amount without any transformations.

The NearToken equivalent to this method is NearToken::as_yoctonear.

pub const fn to_whole(&self) -> u128

Returns the amount as a whole number in the integer precision.

The method rounds down the fractional part, so 2.5 USDT will be 2.

The NearToken equivalent to this method is NearToken::as_near.

pub const fn decimals(&self) -> u8

Returns the number of decimals used by the token.

Trait Implementations

impl Clone for FTBalance

fn clone(&self) -> FTBalance

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FTBalance

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

Formats the value using the given formatter.

impl Default for FTBalance

fn default() -> FTBalance

Returns the “default value” for a type.

impl Deserialize<'static> for FTBalance

fn deserialize<__D>( __deserializer: __D, ) -> Result<FTBalance, <__D as Deserializer<'static>>::Error>

where __D: Deserializer<'static>,

Deserialize this value from the given Serde deserializer.

impl Display for FTBalance

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

Formats the value using the given formatter.

impl PartialEq for FTBalance

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

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for FTBalance

impl StructuralPartialEq for FTBalance