Struct ParsedSymbol 

pub struct ParsedSymbol {
    pub base: String,
    pub quote: String,
    pub settle: Option<String>,
    pub expiry: Option<ExpiryDate>,
}

Represents a parsed unified symbol with all components

This struct holds all the components of a unified symbol:

• base: Base currency (e.g., “BTC”)
• quote: Quote currency (e.g., “USDT”)
• settle: Settlement currency for derivatives (e.g., “USDT” or “BTC”)
• expiry: Expiry date for futures contracts

Example

use ccxt_core::types::symbol::{ParsedSymbol, ExpiryDate, SymbolMarketType};

// Spot symbol
let spot = ParsedSymbol::spot("BTC".to_string(), "USDT".to_string());
assert_eq!(spot.to_string(), "BTC/USDT");

// Linear swap
let swap = ParsedSymbol::linear_swap("BTC".to_string(), "USDT".to_string());
assert_eq!(swap.to_string(), "BTC/USDT:USDT");

// Futures with expiry
let expiry = ExpiryDate::new(24, 12, 31).unwrap();
let futures = ParsedSymbol::futures("BTC".to_string(), "USDT".to_string(), "USDT".to_string(), expiry);
assert_eq!(futures.to_string(), "BTC/USDT:USDT-241231");

Fields

base: String

Base currency (e.g., “BTC”)

quote: String

Quote currency (e.g., “USDT”)

settle: Option<String>

Settlement currency for derivatives (e.g., “USDT” or “BTC”)

expiry: Option<ExpiryDate>

Expiry date for futures contracts

Implementations

impl ParsedSymbol

pub fn spot(base: impl AsRef<str>, quote: impl AsRef<str>) -> ParsedSymbol

Create a new spot symbol

Arguments

• base - Base currency code (e.g., “BTC”)
• quote - Quote currency code (e.g., “USDT”)

Example

use ccxt_core::types::symbol::ParsedSymbol;

let symbol = ParsedSymbol::spot("BTC".to_string(), "USDT".to_string());
assert_eq!(symbol.to_string(), "BTC/USDT");

pub fn linear_swap( base: impl AsRef<str>, quote: impl AsRef<str>, ) -> ParsedSymbol

Create a new linear swap symbol (settled in quote currency)

Arguments

• base - Base currency code (e.g., “BTC”)
• quote - Quote currency code (e.g., “USDT”)

Example

use ccxt_core::types::symbol::ParsedSymbol;

let symbol = ParsedSymbol::linear_swap("BTC".to_string(), "USDT".to_string());
assert_eq!(symbol.to_string(), "BTC/USDT:USDT");

pub fn inverse_swap( base: impl AsRef<str>, quote: impl AsRef<str>, ) -> ParsedSymbol

Create a new inverse swap symbol (settled in base currency)

Arguments

• base - Base currency code (e.g., “BTC”)
• quote - Quote currency code (e.g., “USD”)

Example

use ccxt_core::types::symbol::ParsedSymbol;

let symbol = ParsedSymbol::inverse_swap("BTC".to_string(), "USD".to_string());
assert_eq!(symbol.to_string(), "BTC/USD:BTC");

pub fn swap( base: impl AsRef<str>, quote: impl AsRef<str>, settle: impl AsRef<str>, ) -> ParsedSymbol

Create a new swap symbol with explicit settlement currency

Arguments

• base - Base currency code
• quote - Quote currency code
• settle - Settlement currency code

pub fn futures( base: impl AsRef<str>, quote: impl AsRef<str>, settle: impl AsRef<str>, expiry: ExpiryDate, ) -> ParsedSymbol

Create a new futures symbol

Arguments

• base - Base currency code
• quote - Quote currency code
• settle - Settlement currency code
• expiry - Expiry date

Example

use ccxt_core::types::symbol::{ParsedSymbol, ExpiryDate};

let expiry = ExpiryDate::new(24, 12, 31).unwrap();
let symbol = ParsedSymbol::futures("BTC".to_string(), "USDT".to_string(), "USDT".to_string(), expiry);
assert_eq!(symbol.to_string(), "BTC/USDT:USDT-241231");

pub fn market_type(&self) -> SymbolMarketType

Determine the market type from symbol structure

• No settle and no expiry → Spot
• Has settle but no expiry → Swap
• Has settle and expiry → Futures

pub fn contract_type(&self) -> Option<ContractType>

Determine if this is a linear or inverse contract

Returns None for spot markets.

• Linear: settle == quote
• Inverse: settle == base

pub fn is_spot(&self) -> bool

Check if this is a spot symbol

pub fn is_swap(&self) -> bool

Check if this is a swap (perpetual) symbol

pub fn is_futures(&self) -> bool

Check if this is a futures symbol

pub fn is_derivative(&self) -> bool

Check if this is a derivative (swap or futures)

pub fn is_linear(&self) -> bool

Check if this is a linear contract

pub fn is_inverse(&self) -> bool

Check if this is an inverse contract

Trait Implementations

impl Clone for ParsedSymbol

fn clone(&self) -> ParsedSymbol

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParsedSymbol

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

Formats the value using the given formatter.

impl Default for ParsedSymbol

fn default() -> ParsedSymbol

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ParsedSymbol

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ParsedSymbol

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

Formats the value using the given formatter.

impl FromStr for ParsedSymbol

Implement FromStr for ParsedSymbol to enable string parsing

type Err = SymbolError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl Hash for ParsedSymbol

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 ParsedSymbol

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

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 ParsedSymbol