Struct ExchangeCapabilities 

pub struct ExchangeCapabilities { /* private fields */ }

Exchange capabilities configuration

This struct provides a high-level API for working with exchange capabilities, maintaining backward compatibility with the original boolean-field design while using efficient bitflags internally.

Example

use ccxt_core::capability::ExchangeCapabilities;

let caps = ExchangeCapabilities::public_only();
assert!(caps.has("fetchTicker"));
assert!(!caps.has("createOrder"));

let caps = ExchangeCapabilities::all();
assert!(caps.fetch_ticker());
assert!(caps.create_order());

Implementations

impl ExchangeCapabilities

pub const fn none() -> ExchangeCapabilities

Create with no capabilities enabled

pub const fn all() -> ExchangeCapabilities

Create capabilities with all features enabled

Example

use ccxt_core::capability::ExchangeCapabilities;

let caps = ExchangeCapabilities::all();
assert!(caps.fetch_ticker());
assert!(caps.create_order());
assert!(caps.websocket());

pub const fn public_only() -> ExchangeCapabilities

Create capabilities for public API only (no authentication required)

Example

use ccxt_core::capability::ExchangeCapabilities;

let caps = ExchangeCapabilities::public_only();
assert!(caps.fetch_ticker());
assert!(!caps.create_order());

pub const fn from_capabilities(caps: Capabilities) -> ExchangeCapabilities

Create from raw Capabilities bitflags

pub const fn as_capabilities(&self) -> Capabilities

Get the underlying Capabilities bitflags

pub fn has(&self, capability: &str) -> bool

Check if a capability is supported by name

This method allows checking capabilities using CCXT-style camelCase names.

Arguments

• capability - The capability name in camelCase format

Example

use ccxt_core::capability::ExchangeCapabilities;

let caps = ExchangeCapabilities::all();
assert!(caps.has("fetchTicker"));
assert!(caps.has("createOrder"));
assert!(!caps.has("unknownCapability"));

pub fn supported_capabilities(&self) -> Vec<&'static str>

Get a list of all supported capability names

pub fn count(&self) -> u32

Count the number of enabled capabilities

pub const fn fetch_markets(&self) -> bool

Can fetch market definitions

pub const fn fetch_currencies(&self) -> bool

Can fetch currency definitions

pub const fn fetch_ticker(&self) -> bool

Can fetch single ticker

pub const fn fetch_tickers(&self) -> bool

Can fetch multiple tickers

pub const fn fetch_order_book(&self) -> bool

Can fetch order book

pub const fn fetch_trades(&self) -> bool

Can fetch public trades

pub const fn fetch_ohlcv(&self) -> bool

Can fetch OHLCV candlestick data

pub const fn fetch_status(&self) -> bool

Can fetch exchange status

pub const fn fetch_time(&self) -> bool

Can fetch server time

pub const fn create_order(&self) -> bool

Can create orders

pub const fn create_market_order(&self) -> bool

Can create market orders

pub const fn create_limit_order(&self) -> bool

Can create limit orders

pub const fn cancel_order(&self) -> bool

Can cancel orders

pub const fn cancel_all_orders(&self) -> bool

Can cancel all orders

pub const fn edit_order(&self) -> bool

Can edit/modify orders

pub const fn fetch_order(&self) -> bool

Can fetch single order

pub const fn fetch_orders(&self) -> bool

Can fetch all orders

pub const fn fetch_open_orders(&self) -> bool

Can fetch open orders

pub const fn fetch_closed_orders(&self) -> bool

Can fetch closed orders

pub const fn fetch_canceled_orders(&self) -> bool

Can fetch canceled orders

pub const fn fetch_balance(&self) -> bool

Can fetch account balance

pub const fn fetch_my_trades(&self) -> bool

Can fetch user’s trade history

pub const fn fetch_deposits(&self) -> bool

Can fetch deposit history

pub const fn fetch_withdrawals(&self) -> bool

Can fetch withdrawal history

pub const fn fetch_transactions(&self) -> bool

Can fetch transaction history

pub const fn fetch_ledger(&self) -> bool

Can fetch ledger entries

pub const fn fetch_deposit_address(&self) -> bool

Can fetch deposit address

pub const fn create_deposit_address(&self) -> bool

Can create deposit address

pub const fn withdraw(&self) -> bool

Can withdraw funds

pub const fn transfer(&self) -> bool

Can transfer between accounts

pub const fn fetch_borrow_rate(&self) -> bool

Can fetch borrow rate

pub const fn fetch_borrow_rates(&self) -> bool

Can fetch multiple borrow rates

pub const fn fetch_funding_rate(&self) -> bool

Can fetch funding rate

pub const fn fetch_funding_rates(&self) -> bool

Can fetch multiple funding rates

pub const fn fetch_positions(&self) -> bool

Can fetch positions

pub const fn set_leverage(&self) -> bool

Can set leverage

pub const fn set_margin_mode(&self) -> bool

Can set margin mode

pub const fn websocket(&self) -> bool

WebSocket support available

pub const fn watch_ticker(&self) -> bool

Can watch ticker updates

pub const fn watch_tickers(&self) -> bool

Can watch multiple ticker updates

pub const fn watch_order_book(&self) -> bool

Can watch order book updates

pub const fn watch_trades(&self) -> bool

Can watch trade updates

pub const fn watch_ohlcv(&self) -> bool

Can watch OHLCV updates

pub const fn watch_balance(&self) -> bool

Can watch balance updates

pub const fn watch_orders(&self) -> bool

Can watch order updates

pub const fn watch_my_trades(&self) -> bool

Can watch user trade updates

pub fn builder() -> ExchangeCapabilitiesBuilder

Create a builder for ExchangeCapabilities

Example

use ccxt_core::capability::ExchangeCapabilities;

let caps = ExchangeCapabilities::builder()
    .market_data()
    .trading()
    .websocket()
    .build();
assert!(caps.fetch_ticker());
assert!(caps.create_order());
assert!(caps.websocket());

impl ExchangeCapabilities

pub const fn spot_exchange() -> ExchangeCapabilities

Create capabilities for a typical spot exchange

Includes: market data, trading, account, and basic WebSocket

pub const fn futures_exchange() -> ExchangeCapabilities

Create capabilities for a typical futures exchange

Includes: spot capabilities + margin trading

pub const fn full_featured() -> ExchangeCapabilities

Create capabilities for a full-featured exchange (like Binance)

Includes: all capabilities

impl ExchangeCapabilities

pub const fn supports_market_data(&self) -> bool

Check if the exchange supports the MarketData trait.

Returns true if the exchange has the minimum capabilities required to implement the MarketData trait (fetch_markets and fetch_ticker).

Example

use ccxt_core::capability::ExchangeCapabilities;

let caps = ExchangeCapabilities::public_only();
assert!(caps.supports_market_data());

let caps = ExchangeCapabilities::none();
assert!(!caps.supports_market_data());

pub const fn supports_trading(&self) -> bool

Check if the exchange supports the Trading trait.

Returns true if the exchange has the minimum capabilities required to implement the Trading trait (create_order and cancel_order).

Example

use ccxt_core::capability::ExchangeCapabilities;

let caps = ExchangeCapabilities::all();
assert!(caps.supports_trading());

let caps = ExchangeCapabilities::public_only();
assert!(!caps.supports_trading());

pub const fn supports_account(&self) -> bool

Check if the exchange supports the Account trait.

Returns true if the exchange has the minimum capabilities required to implement the Account trait (fetch_balance).

Example

use ccxt_core::capability::ExchangeCapabilities;

let caps = ExchangeCapabilities::all();
assert!(caps.supports_account());

let caps = ExchangeCapabilities::public_only();
assert!(!caps.supports_account());

pub const fn supports_margin(&self) -> bool

Check if the exchange supports the Margin trait.

Returns true if the exchange has the minimum capabilities required to implement the Margin trait (fetch_positions).

Example

use ccxt_core::capability::ExchangeCapabilities;

let caps = ExchangeCapabilities::futures_exchange();
assert!(caps.supports_margin());

let caps = ExchangeCapabilities::spot_exchange();
assert!(!caps.supports_margin());

pub const fn supports_funding(&self) -> bool

Check if the exchange supports the Funding trait.

Returns true if the exchange has the minimum capabilities required to implement the Funding trait (fetch_deposit_address).

Example

use ccxt_core::capability::ExchangeCapabilities;

let caps = ExchangeCapabilities::all();
assert!(caps.supports_funding());

let caps = ExchangeCapabilities::public_only();
assert!(!caps.supports_funding());

pub const fn supports_websocket(&self) -> bool

Check if the exchange supports WebSocket.

Returns true if the exchange has the base WebSocket capability.

Example

use ccxt_core::capability::ExchangeCapabilities;

let caps = ExchangeCapabilities::all();
assert!(caps.supports_websocket());

let caps = ExchangeCapabilities::public_only();
assert!(!caps.supports_websocket());

pub const fn supports_full_exchange(&self) -> bool

Check if the exchange supports all traits (FullExchange).

Returns true if the exchange has the minimum capabilities required to implement all traits: MarketData, Trading, Account, Margin, and Funding.

Example

use ccxt_core::capability::ExchangeCapabilities;

let caps = ExchangeCapabilities::all();
assert!(caps.supports_full_exchange());

let caps = ExchangeCapabilities::spot_exchange();
assert!(!caps.supports_full_exchange());

pub const fn supports_trait(&self, category: TraitCategory) -> bool

Check if the exchange supports a specific trait category.

Arguments

• category - The trait category to check

Example

use ccxt_core::capability::{ExchangeCapabilities, TraitCategory};

let caps = ExchangeCapabilities::all();
assert!(caps.supports_trait(TraitCategory::MarketData));
assert!(caps.supports_trait(TraitCategory::Trading));

pub fn supported_traits(&self) -> Vec<TraitCategory>

Get a list of supported trait categories.

Returns a vector of trait categories that this exchange supports based on its capabilities.

Example

use ccxt_core::capability::{ExchangeCapabilities, TraitCategory};

let caps = ExchangeCapabilities::public_only();
let traits = caps.supported_traits();
assert!(traits.contains(&TraitCategory::PublicExchange));
assert!(traits.contains(&TraitCategory::MarketData));
assert!(!traits.contains(&TraitCategory::Trading));

pub const fn capabilities_for_trait( &self, category: TraitCategory, ) -> Capabilities

Get capabilities for a specific trait category.

Returns the capabilities that are enabled for the specified trait category.

Arguments

• category - The trait category to get capabilities for

Example

use ccxt_core::capability::{ExchangeCapabilities, TraitCategory, Capabilities};

let caps = ExchangeCapabilities::all();
let market_caps = caps.capabilities_for_trait(TraitCategory::MarketData);
assert!(market_caps.contains(Capabilities::FETCH_TICKER));

pub const fn trait_for_capability(capability: Capability) -> TraitCategory

Get the trait category for a specific capability.

Arguments

• capability - The capability to get the trait category for

Example

use ccxt_core::capability::{ExchangeCapabilities, Capability, TraitCategory};

let category = ExchangeCapabilities::trait_for_capability(Capability::FetchTicker);
assert_eq!(category, TraitCategory::MarketData);

Trait Implementations

impl Clone for ExchangeCapabilities

fn clone(&self) -> ExchangeCapabilities

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExchangeCapabilities

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

Formats the value using the given formatter.

impl Default for ExchangeCapabilities

fn default() -> ExchangeCapabilities

Returns the “default value” for a type.

impl Display for ExchangeCapabilities

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

Formats the value using the given formatter.

impl From<Capabilities> for ExchangeCapabilities

fn from(caps: Capabilities) -> ExchangeCapabilities

Converts to this type from the input type.

impl Hash for ExchangeCapabilities

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 ExchangeCapabilities

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

impl Eq for ExchangeCapabilities

impl StructuralPartialEq for ExchangeCapabilities