Enum DefaultType 

pub enum DefaultType {
    Spot,
    Swap,
    Futures,
    Margin,
    Option,
}

Default market type for exchange operations

This enum determines which API endpoints and market filters to use when calling generic exchange methods.

Variants

• Spot: Regular cryptocurrency trading without leverage or expiry
• Swap: Perpetual contracts with no expiry date (also called perpetual futures)
• Futures: Delivery contracts with a specific expiry date
• Margin: Spot trading with borrowed funds (leverage)
• Option: Options contracts (calls and puts)

Example

use ccxt_core::types::default_type::DefaultType;

let default = DefaultType::default();
assert_eq!(default, DefaultType::Spot);

assert!(DefaultType::Swap.is_derivative());
assert!(DefaultType::Futures.is_contract());
assert!(!DefaultType::Spot.is_derivative());

Variants

Spot

Spot market - regular cryptocurrency trading

Swap

Swap market - perpetual contracts with no expiry

Futures

Futures market - delivery contracts with expiry date

Margin

Margin market - spot trading with borrowed funds

Option

Option market - options contracts (calls and puts)

Implementations

impl DefaultType

pub const ALL: &'static [DefaultType]

All valid default type variants

pub fn as_str(&self) -> &'static str

Returns the string representation (lowercase)

Example

use ccxt_core::types::default_type::DefaultType;

assert_eq!(DefaultType::Spot.as_str(), "spot");
assert_eq!(DefaultType::Swap.as_str(), "swap");

pub fn is_derivative(&self) -> bool

Check if this type represents a derivative market

Derivatives include swap, futures, margin, and option markets.

Example

use ccxt_core::types::default_type::DefaultType;

assert!(!DefaultType::Spot.is_derivative());
assert!(DefaultType::Swap.is_derivative());
assert!(DefaultType::Futures.is_derivative());
assert!(DefaultType::Margin.is_derivative());
assert!(DefaultType::Option.is_derivative());

pub fn is_contract(&self) -> bool

Check if this type represents a contract market (swap, futures, option)

Contract markets are those that trade derivative contracts rather than the underlying asset directly.

Example

use ccxt_core::types::default_type::DefaultType;

assert!(!DefaultType::Spot.is_contract());
assert!(DefaultType::Swap.is_contract());
assert!(DefaultType::Futures.is_contract());
assert!(!DefaultType::Margin.is_contract());
assert!(DefaultType::Option.is_contract());

Trait Implementations

impl Clone for DefaultType

fn clone(&self) -> DefaultType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DefaultType

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

Formats the value using the given formatter.

impl Default for DefaultType

fn default() -> DefaultType

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DefaultType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DefaultType

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

Formats the value using the given formatter.

impl From<&str> for DefaultType

fn from(s: &str) -> DefaultType

Convert a string slice to DefaultType.

Panics if the string is not a valid DefaultType. For fallible conversion, use FromStr::from_str() instead.

Example

use ccxt_core::types::default_type::DefaultType;

let dt: DefaultType = "spot".into();
assert_eq!(dt, DefaultType::Spot);

let dt: DefaultType = "swap".into();
assert_eq!(dt, DefaultType::Swap);

Panics

Panics if the string is not a valid DefaultType value.

impl From<DefaultType> for MarketType

fn from(dt: DefaultType) -> MarketType

Convert DefaultType to MarketType

Note: Margin maps to Spot since margin trading uses spot markets with leverage.

impl From<String> for DefaultType

fn from(s: String) -> DefaultType

Convert a String to DefaultType.

Falls back to Spot if the string is not a valid DefaultType. For fallible conversion, use FromStr::from_str() instead.

Example

use ccxt_core::types::default_type::DefaultType;

let dt: DefaultType = "swap".to_string().into();
assert_eq!(dt, DefaultType::Swap);

impl FromStr for DefaultType

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

Parse a DefaultType from a string (case-insensitive)

Example

use ccxt_core::types::default_type::DefaultType;
use std::str::FromStr;

assert_eq!(DefaultType::from_str("spot").unwrap(), DefaultType::Spot);
assert_eq!(DefaultType::from_str("SWAP").unwrap(), DefaultType::Swap);
assert_eq!(DefaultType::from_str("Futures").unwrap(), DefaultType::Futures);

assert!(DefaultType::from_str("invalid").is_err());

type Err = DefaultTypeError

The associated error which can be returned from parsing.

impl Hash for DefaultType

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 DefaultType

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

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 TryFrom<MarketType> for DefaultType

fn try_from( mt: MarketType, ) -> Result<DefaultType, <DefaultType as TryFrom<MarketType>>::Error>

Convert MarketType to DefaultType

Note: MarketType::Spot could be either DefaultType::Spot or DefaultType::Margin, so this conversion defaults to Spot.

type Error = DefaultTypeError

The type returned in the event of a conversion error.

impl Copy for DefaultType

impl Eq for DefaultType

impl StructuralPartialEq for DefaultType