Struct Bitget 

pub struct Bitget { /* private fields */ }

Bitget exchange structure.

Implementations

impl Bitget

pub async fn fetch_balance(&self) -> Result<Balance>

Fetch account balances.

pub async fn fetch_my_trades( &self, symbol: &str, since: Option<i64>, limit: Option<u32>, ) -> Result<Vec<Trade>>

Fetch user’s trade history.

impl Bitget

pub async fn fetch_funding_rate_impl(&self, symbol: &str) -> Result<FundingRate>

Fetch current funding rate for a symbol.

Uses Bitget GET /api/v2/mix/market/current-fund-rate (public endpoint).

pub async fn fetch_funding_rates_impl( &self, symbols: &[&str], ) -> Result<Vec<FundingRate>>

Fetch funding rates for multiple symbols.

pub async fn fetch_funding_rate_history_impl( &self, symbol: &str, since: Option<i64>, limit: Option<u32>, ) -> Result<Vec<FundingRateHistory>>

Fetch funding rate history for a symbol.

Uses Bitget GET /api/v2/mix/market/history-fund-rate (public endpoint).

impl Bitget

pub async fn set_leverage_impl( &self, symbol: &str, leverage: u32, margin_mode: Option<&str>, ) -> Result<()>

Set leverage for a symbol.

Uses Bitget POST /api/v2/mix/account/set-leverage endpoint.

pub async fn get_leverage_impl(&self, symbol: &str) -> Result<u32>

Get current leverage for a symbol.

Uses Bitget GET /api/v2/mix/account/account endpoint and extracts leverage.

impl Bitget

pub async fn set_margin_mode_impl(&self, symbol: &str, mode: &str) -> Result<()>

Set margin mode (cross or isolated) for a symbol.

Uses Bitget POST /api/v2/mix/account/set-margin-mode endpoint.

impl Bitget

pub async fn fetch_position_impl(&self, symbol: &str) -> Result<Position>

Fetch a single position for a symbol.

Uses Bitget GET /api/v2/mix/position/single-position endpoint.

pub async fn fetch_positions_impl( &self, symbols: &[&str], ) -> Result<Vec<Position>>

Fetch positions for specific symbols, or all positions if empty.

Uses Bitget GET /api/v2/mix/position/all-position endpoint.

impl Bitget

pub async fn fetch_markets(&self) -> Result<Arc<HashMap<String, Arc<Market>>>>

Fetch all trading markets.

pub async fn load_markets( &self, reload: bool, ) -> Result<Arc<HashMap<String, Arc<Market>>>>

Load and cache market data.

pub async fn fetch_ticker(&self, symbol: &str) -> Result<Ticker>

Fetch ticker for a single trading pair.

pub async fn fetch_tickers( &self, symbols: Option<Vec<String>>, ) -> Result<Vec<Ticker>>

Fetch tickers for multiple trading pairs.

pub async fn fetch_order_book( &self, symbol: &str, limit: Option<u32>, ) -> Result<OrderBook>

Fetch order book for a trading pair.

pub async fn fetch_trades( &self, symbol: &str, limit: Option<u32>, ) -> Result<Vec<Trade>>

Fetch recent public trades.

pub async fn fetch_ohlcv_v2(&self, request: OhlcvRequest) -> Result<Vec<OHLCV>>

Fetch OHLCV (candlestick) data.

pub async fn fetch_ohlcv( &self, symbol: &str, timeframe: &str, since: Option<i64>, limit: Option<u32>, ) -> Result<Vec<OHLCV>>

👎Deprecated since 0.2.0: Use fetch_ohlcv_v2 with OhlcvRequest::builder() instead

Fetch OHLCV (candlestick) data (deprecated).

impl Bitget

pub async fn create_order_v2(&self, request: OrderRequest) -> Result<Order>

Create a new order.

pub async fn create_order( &self, symbol: &str, order_type: OrderType, side: OrderSide, amount: Amount, price: Option<Price>, ) -> Result<Order>

👎Deprecated since 0.2.0: Use create_order_v2 with OrderRequest::builder() instead

Create a new order (deprecated).

pub async fn cancel_order(&self, id: &str, symbol: &str) -> Result<Order>

Cancel an existing order.

pub async fn fetch_order(&self, id: &str, symbol: &str) -> Result<Order>

Fetch a single order by ID.

pub async fn fetch_open_orders( &self, symbol: Option<&str>, since: Option<i64>, limit: Option<u32>, ) -> Result<Vec<Order>>

Fetch open orders.

pub async fn fetch_closed_orders( &self, symbol: Option<&str>, since: Option<i64>, limit: Option<u32>, ) -> Result<Vec<Order>>

Fetch closed orders.

impl Bitget

pub fn get_auth(&self) -> Result<BitgetAuth>

Get the authentication instance if credentials are configured.

pub fn check_required_credentials(&self) -> Result<()>

Check that required credentials are configured.

impl Bitget

pub fn builder() -> BitgetBuilder

Creates a new Bitget instance using the builder pattern.

This is the recommended way to create a Bitget instance.

Example

use ccxt_exchanges::bitget::Bitget;

let bitget = Bitget::builder()
    .api_key("your-api-key")
    .secret("your-secret")
    .passphrase("your-passphrase")
    .sandbox(true)
    .build()
    .unwrap();

pub fn new(config: ExchangeConfig) -> Result<Self>

Creates a new Bitget instance.

Arguments

• config - Exchange configuration.

pub fn new_with_options( config: ExchangeConfig, options: BitgetOptions, ) -> Result<Self>

Creates a new Bitget instance with custom options.

This is used internally by the builder pattern.

Arguments

• config - Exchange configuration.
• options - Bitget-specific options.

pub fn base(&self) -> &BaseExchange

Returns a reference to the base exchange.

pub fn base_mut(&mut self) -> &mut BaseExchange

Returns a mutable reference to the base exchange.

pub fn options(&self) -> &BitgetOptions

Returns the Bitget options.

pub fn set_options(&mut self, options: BitgetOptions)

Sets the Bitget options.

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

Returns the exchange ID.

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

Returns the exchange name.

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

Returns the API version.

pub fn certified(&self) -> bool

Returns true if the exchange is CCXT-certified.

pub fn pro(&self) -> bool

Returns true if Pro version (WebSocket) is supported.

pub fn rate_limit(&self) -> u32

Returns the rate limit in requests per second.

pub fn is_sandbox(&self) -> bool

Returns true if sandbox/testnet mode is enabled.

Sandbox mode is enabled when either:

• config.sandbox is set to true
• options.testnet is set to true

Returns

true if sandbox mode is enabled, false otherwise.

Example

use ccxt_exchanges::bitget::Bitget;
use ccxt_core::ExchangeConfig;

let config = ExchangeConfig {
    sandbox: true,
    ..Default::default()
};
let bitget = Bitget::new(config).unwrap();
assert!(bitget.is_sandbox());

pub fn timeframes(&self) -> HashMap<String, String>

Returns the supported timeframes.

pub fn urls(&self) -> BitgetUrls

Returns the API URLs.

Returns testnet URLs when sandbox mode is enabled (via config.sandbox or options.testnet), otherwise returns production URLs.

Returns

• BitgetUrls::testnet() when sandbox mode is enabled
• BitgetUrls::production() when sandbox mode is disabled

pub fn create_ws(&self) -> BitgetWs

Creates a public WebSocket client.

Returns

Returns a BitgetWs instance for public data streams.

Example

use ccxt_exchanges::bitget::Bitget;
use ccxt_core::ExchangeConfig;

let bitget = Bitget::new(ExchangeConfig::default())?;
let ws = bitget.create_ws();
ws.connect().await?;

pub fn create_private_ws(&self) -> BitgetWs

Creates a new private WebSocket client for Bitget.

Returns a BitgetWs instance configured with the private WebSocket URL. The caller must call login() on the returned client before subscribing to private channels.

pub fn signed_request( &self, endpoint: impl Into<String>, ) -> BitgetSignedRequestBuilder<'_>

Creates a signed request builder for authenticated API requests.

Arguments

• endpoint - API endpoint path (e.g., “/api/v2/spot/account/assets”)

Returns

Returns a BitgetSignedRequestBuilder for fluent API construction.

Example

use ccxt_exchanges::bitget::Bitget;
use ccxt_exchanges::bitget::signed_request::HttpMethod;
use ccxt_core::ExchangeConfig;

let bitget = Bitget::new(ExchangeConfig::default())?;

let data = bitget.signed_request("/api/v2/spot/account/assets")
    .execute()
    .await?;

Trait Implementations

impl BitgetEndpointRouter for Bitget

fn rest_endpoint(&self) -> &'static str

Returns the REST API endpoint.

fn ws_endpoint(&self, endpoint_type: EndpointType) -> &str

Returns the WebSocket endpoint for a specific endpoint type.

impl Debug for Bitget

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

Formats the value using the given formatter.

impl Exchange for Bitget

fn id(&self) -> &'static str

Returns the exchange identifier (e.g., “binance”, “coinbase”)

fn name(&self) -> &'static str

Returns the human-readable exchange name (e.g., “Binance”, “Coinbase”)

fn version(&self) -> &'static str

Returns the API version string

fn certified(&self) -> bool

Returns whether this exchange is CCXT certified

fn has_websocket(&self) -> bool

Returns whether this exchange supports WebSocket (pro features)

fn capabilities(&self) -> ExchangeCapabilities

Returns the exchange capabilities

fn timeframes(&self) -> Vec<Timeframe>

Returns supported timeframes for OHLCV data

fn rate_limit(&self) -> u32

Returns the rate limit (requests per second)

fn fetch_markets<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<Market>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Fetch all available markets

fn load_markets<'life0, 'async_trait>( &'life0 self, reload: bool, ) -> Pin<Box<dyn Future<Output = Result<Arc<HashMap<String, Arc<Market>>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load markets and cache them

fn fetch_ticker<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Ticker>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch ticker for a single symbol

fn fetch_tickers<'life0, 'life1, 'async_trait>( &'life0 self, symbols: Option<&'life1 [String]>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Ticker>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch tickers for multiple symbols (or all if None)

fn fetch_order_book<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<OrderBook>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch order book for a symbol

fn fetch_trades<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Trade>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch recent public trades

fn fetch_ohlcv<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, timeframe: Timeframe, since: Option<i64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Ohlcv>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch OHLCV candlestick data

fn create_order<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, order_type: OrderType, side: OrderSide, amount: Amount, price: Option<Price>, ) -> Pin<Box<dyn Future<Output = Result<Order>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create a new order

fn cancel_order<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, symbol: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<Order>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Cancel an existing order

fn cancel_all_orders<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Order>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Cancel all orders (optionally for a specific symbol)

fn fetch_order<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 str, symbol: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<Order>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch a specific order by ID

fn fetch_open_orders<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, since: Option<i64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Order>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch all open orders

fn fetch_closed_orders<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, since: Option<i64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Order>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch closed orders

fn fetch_balance<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Balance>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Fetch account balance

fn fetch_my_trades<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, since: Option<i64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Trade>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch user’s trade history

fn market<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<Market>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a specific market by symbol

fn markets<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Arc<HashMap<String, Arc<Market>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get all cached markets

fn is_symbol_active<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Check if a symbol is valid and active

impl Margin for Bitget

fn fetch_positions_for<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, symbols: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = Result<Vec<Position>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch positions for specific symbols.

fn fetch_position<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Position>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a single position for a symbol.

fn set_leverage_with_params<'life0, 'async_trait>( &'life0 self, params: LeverageParams, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set leverage with full parameters.

fn get_leverage<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<u32>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get current leverage for a symbol.

fn set_margin_mode<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, mode: MarginMode, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Set margin mode for a symbol.

fn fetch_funding_rate<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<FundingRate>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch current funding rate for a symbol.

fn fetch_funding_rates<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, symbols: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = Result<Vec<FundingRate>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch funding rates for multiple symbols.

fn fetch_funding_rate_history<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, since: Option<i64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<FundingRateHistory>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch funding rate history for a symbol.

fn fetch_positions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<Position>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Fetch all positions.

fn set_leverage<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, leverage: u32, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Set leverage for a symbol.

fn fetch_funding_rate_history_u64<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, since: Option<u64>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<FundingRateHistory>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

👎Deprecated since 0.1.0: Use fetch_funding_rate_history with i64 timestamps. Convert using TimestampUtils::u64_to_i64()

Fetch funding rate history with u64 timestamp filtering (deprecated).

impl PublicExchange for Bitget

fn id(&self) -> &'static str

Returns the exchange identifier (e.g., “binance”, “okx”).

fn name(&self) -> &'static str

Returns the human-readable exchange name (e.g., “Binance”, “OKX”).

fn version(&self) -> &'static str

Returns the API version string.

fn certified(&self) -> bool

Returns whether this exchange implementation is CCXT certified.

fn capabilities(&self) -> ExchangeCapabilities

Returns the exchange capabilities.

fn timeframes(&self) -> Vec<Timeframe>

Returns supported timeframes for OHLCV data.

fn rate_limit(&self) -> u32

Returns the rate limit (requests per second).

fn has_websocket(&self) -> bool

Returns whether WebSocket is supported.

fn is_sandbox(&self) -> bool

Returns whether the exchange is in sandbox/testnet mode.

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

Returns the exchange’s countries of operation.

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

Returns the exchange’s website URLs.

fn has_capability(&self, name: &str) -> bool

Check if a specific capability is supported.

impl WsExchange for Bitget

fn ws_connect<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Connect to the WebSocket server

fn ws_disconnect<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Disconnect from the WebSocket server

fn ws_is_connected(&self) -> bool

Check if WebSocket is connected

fn ws_state(&self) -> WsConnectionState

Get WebSocket connection state

fn watch_ticker<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<MessageStream<Ticker>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Watch ticker updates for a symbol

fn watch_tickers<'life0, 'life1, 'async_trait>( &'life0 self, symbols: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<MessageStream<Vec<Ticker>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Watch tickers for multiple symbols

fn watch_order_book<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<MessageStream<OrderBook>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Watch order book updates

fn watch_trades<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<MessageStream<Vec<Trade>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Watch public trades

fn watch_ohlcv<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: &'life1 str, _timeframe: Timeframe, ) -> Pin<Box<dyn Future<Output = Result<MessageStream<Ohlcv>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Watch OHLCV candlestick updates

fn watch_balance<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<MessageStream<Balance>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Watch account balance updates

fn watch_orders<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<MessageStream<Order>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Watch order updates

fn watch_my_trades<'life0, 'life1, 'async_trait>( &'life0 self, symbol: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<MessageStream<Trade>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Watch user trade updates

fn subscribe<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _channel: &'life1 str, _symbol: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Subscribe to a channel

fn unsubscribe<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _channel: &'life1 str, _symbol: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Unsubscribe from a channel

fn subscriptions(&self) -> Vec<String>

Get list of active subscriptions