Struct Currency 

pub struct Currency {
    pub code: String,
    pub id: String,
    pub name: Option<String>,
    pub active: bool,
    pub deposit: bool,
    pub withdraw: bool,
    pub fee: Option<Decimal>,
    pub precision: Option<Decimal>,
    pub limits: MinMax,
    pub networks: HashMap<String, CurrencyNetwork>,
    pub currency_type: Option<String>,
    pub info: HashMap<String, Value>,
}

Currency structure representing a tradable asset

This corresponds to Go’s currency metadata and contains information about a cryptocurrency or fiat currency on an exchange.

Fields

code: String

Currency code (e.g., “BTC”, “USDT”)

id: String

Exchange-specific currency ID

name: Option<String>

Full currency name

active: bool

Is currency active for trading

deposit: bool

Deposit enabled

withdraw: bool

Withdrawal enabled

fee: Option<Decimal>

Trading fee for this currency

precision: Option<Decimal>

Precision (decimal places)

limits: MinMax

Withdrawal/deposit limits

networks: HashMap<String, CurrencyNetwork>

Available networks for this currency

currency_type: Option<String>

Currency type (crypto/fiat)

info: HashMap<String, Value>

Raw exchange info

Implementations

impl Currency

pub fn new(code: String, id: String) -> Currency

Create a new currency

pub fn new_crypto(code: String, id: String, name: String) -> Currency

Create a new cryptocurrency

pub fn new_fiat(code: String, id: String, name: String) -> Currency

Create a new fiat currency

pub fn is_active(&self) -> bool

Check if currency is active

pub fn can_deposit(&self) -> bool

Check if deposit is enabled

pub fn can_withdraw(&self) -> bool

Check if withdrawal is enabled

pub fn is_crypto(&self) -> bool

Check if currency is a cryptocurrency

pub fn is_fiat(&self) -> bool

Check if currency is a fiat currency

pub fn add_network(&mut self, network: CurrencyNetwork)

Add a network to this currency

pub fn get_network(&self, network: &str) -> Option<&CurrencyNetwork>

Get a specific network

pub fn available_networks(&self) -> Vec<&CurrencyNetwork>

Get all available networks

Trait Implementations

impl Clone for Currency

fn clone(&self) -> Currency

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Currency

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Currency

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Currency

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

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 Currency

impl StructuralPartialEq for Currency