Struct Bitget 

pub struct Bitget { /* private fields */ }

Bitget exchange structure.

Implementations

impl Bitget

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

Get the authentication instance if credentials are configured.

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

Check that required credentials are configured.

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

Fetch all trading markets.

Returns

Returns a vector of Market structures containing market information.

Errors

Returns an error if the API request fails or response parsing fails.

Example

let bitget = Bitget::builder().build()?;
let markets = bitget.fetch_markets().await?;
println!("Found {} markets", markets.len());

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

Load and cache market data.

If markets are already loaded and reload is false, returns cached data.

Arguments

• reload - Whether to force reload market data from the API.

Returns

Returns a HashMap containing all market data, keyed by symbol (e.g., “BTC/USDT”).

Errors

Returns an error if the API request fails or response parsing fails.

Example

let bitget = Bitget::builder().build()?;

// Load markets for the first time
let markets = bitget.load_markets(false).await?;
println!("Loaded {} markets", markets.len());

// Subsequent calls use cache (no API request)
let markets = bitget.load_markets(false).await?;

// Force reload
let markets = bitget.load_markets(true).await?;

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

Fetch ticker for a single trading pair.

Arguments

• symbol - Trading pair symbol (e.g., “BTC/USDT”).

Returns

Returns Ticker data for the specified symbol.

Errors

Returns an error if the market is not found or the API request fails.

Example

let bitget = Bitget::builder().build()?;
bitget.load_markets(false).await?;
let ticker = bitget.fetch_ticker("BTC/USDT").await?;
println!("BTC/USDT last price: {:?}", ticker.last);

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

Fetch tickers for multiple trading pairs.

Arguments

• symbols - Optional list of trading pair symbols; fetches all if None.

Returns

Returns a vector of Ticker structures.

Errors

Returns an error if markets are not loaded or the API request fails.

Example

let bitget = Bitget::builder().build()?;
bitget.load_markets(false).await?;

// Fetch all tickers
let all_tickers = bitget.fetch_tickers(None).await?;

// Fetch specific tickers
let tickers = bitget.fetch_tickers(Some(vec!["BTC/USDT".to_string(), "ETH/USDT".to_string()])).await?;

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

Fetch order book for a trading pair.

Arguments

• symbol - Trading pair symbol.
• limit - Optional depth limit (valid values: 1, 5, 15, 50, 100; default: 100).

Returns

Returns OrderBook data containing bids and asks.

Errors

Returns an error if the market is not found or the API request fails.

Example

let bitget = Bitget::builder().build()?;
bitget.load_markets(false).await?;
let orderbook = bitget.fetch_order_book("BTC/USDT", Some(50)).await?;
println!("Best bid: {:?}", orderbook.bids.first());
println!("Best ask: {:?}", orderbook.asks.first());

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

Fetch recent public trades.

Arguments

• symbol - Trading pair symbol.
• limit - Optional limit on number of trades (maximum: 500).

Returns

Returns a vector of Trade structures, sorted by timestamp in descending order.

Errors

Returns an error if the market is not found or the API request fails.

Example

let bitget = Bitget::builder().build()?;
bitget.load_markets(false).await?;
let trades = bitget.fetch_trades("BTC/USDT", Some(100)).await?;
for trade in trades.iter().take(5) {
    println!("Trade: {:?} @ {:?}", trade.amount, trade.price);
}

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

Fetch OHLCV (candlestick) data.

Arguments

• symbol - Trading pair symbol.
• timeframe - Candlestick timeframe (e.g., “1m”, “5m”, “1h”, “1d”).
• since - Optional start timestamp in milliseconds.
• limit - Optional limit on number of candles (maximum: 1000).

Returns

Returns a vector of OHLCV structures.

Errors

Returns an error if the market is not found or the API request fails.

Example

let bitget = Bitget::builder().build()?;
bitget.load_markets(false).await?;
let ohlcv = bitget.fetch_ohlcv("BTC/USDT", "1h", None, Some(100)).await?;
for candle in ohlcv.iter().take(5) {
    println!("Open: {}, Close: {}", candle.open, candle.close);
}

Requirements: 2.3, 2.6

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

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

Fetch OHLCV (candlestick) data (deprecated).

Deprecated

This method is deprecated. Use fetch_ohlcv_v2 with OhlcvRequest::builder() instead for a more ergonomic API.

Arguments

• symbol - Trading pair symbol.
• timeframe - Candlestick timeframe (e.g., “1m”, “5m”, “1h”, “1d”).
• since - Optional start timestamp in milliseconds.
• limit - Optional limit on number of candles (maximum: 1000).

Returns

Returns a vector of OHLCV structures.

Example

let bitget = Bitget::builder().build()?;
bitget.load_markets(false).await?;
let ohlcv = bitget.fetch_ohlcv("BTC/USDT", "1h", None, Some(100)).await?;
for candle in ohlcv.iter().take(5) {
    println!("Open: {}, Close: {}", candle.open, candle.close);
}

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

Fetch account balances.

Returns

Returns a Balance structure with all currency balances.

Errors

Returns an error if authentication fails or the API request fails.

Example

let bitget = Bitget::builder()
    .api_key("your-api-key")
    .secret("your-secret")
    .passphrase("your-passphrase")
    .build()?;
let balance = bitget.fetch_balance().await?;
if let Some(btc) = balance.get("BTC") {
    println!("BTC balance: free={}, used={}, total={}", btc.free, btc.used, btc.total);
}

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

Fetch user’s trade history.

Arguments

• symbol - Trading pair symbol.
• since - Optional start timestamp in milliseconds.
• limit - Optional limit on number of trades (maximum: 500).

Returns

Returns a vector of Trade structures representing user’s trade history.

Errors

Returns an error if authentication fails or the API request fails.

Example

let bitget = Bitget::builder()
    .api_key("your-api-key")
    .secret("your-secret")
    .passphrase("your-passphrase")
    .build()?;
bitget.load_markets(false).await?;
let my_trades = bitget.fetch_my_trades("BTC/USDT", None, Some(50)).await?;

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

Create a new order.

Arguments

• symbol - Trading pair symbol.
• order_type - Order type (Market, Limit).
• side - Order side (Buy or Sell).
• amount - Order quantity as Amount type.
• price - Optional price as Price type (required for limit orders).

Returns

Returns the created Order structure with order details.

Errors

Returns an error if authentication fails, market is not found, or the API request fails.

Example

let bitget = Bitget::builder()
    .api_key("your-api-key")
    .secret("your-secret")
    .passphrase("your-passphrase")
    .build()?;
bitget.load_markets(false).await?;

// Create a limit buy order
let order = bitget.create_order(
    "BTC/USDT",
    OrderType::Limit,
    OrderSide::Buy,
    Amount::new(dec!(0.001)),
    Some(Price::new(dec!(50000.0))),
).await?;
println!("Order created: {}", order.id);

Requirements: 2.2, 2.6

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

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

Create a new order (deprecated).

Deprecated

This method is deprecated. Use create_order_v2 with OrderRequest::builder() instead for a more ergonomic API.

Arguments

• symbol - Trading pair symbol.
• order_type - Order type (Market, Limit).
• side - Order side (Buy or Sell).
• amount - Order quantity as Amount type.
• price - Optional price as Price type (required for limit orders).

Returns

Returns the created Order structure with order details.

Errors

Returns an error if authentication fails or the API request fails.

Example

let bitget = Bitget::builder()
    .api_key("your-api-key")
    .secret("your-secret")
    .passphrase("your-passphrase")
    .build()?;
bitget.load_markets(false).await?;

// Create a limit buy order
let order = bitget.create_order(
    "BTC/USDT",
    OrderType::Limit,
    OrderSide::Buy,
    Amount::new(dec!(0.001)),
    Some(Price::new(dec!(50000.0))),
).await?;
println!("Order created: {}", order.id);

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

Cancel an existing order.

Arguments

• id - Order ID to cancel.
• symbol - Trading pair symbol.

Returns

Returns the canceled Order structure.

Errors

Returns an error if authentication fails or the API request fails.

Example

let bitget = Bitget::builder()
    .api_key("your-api-key")
    .secret("your-secret")
    .passphrase("your-passphrase")
    .build()?;
bitget.load_markets(false).await?;
let order = bitget.cancel_order("123456789", "BTC/USDT").await?;

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

Fetch a single order by ID.

Arguments

• id - Order ID to fetch.
• symbol - Trading pair symbol.

Returns

Returns the Order structure with current status.

Errors

Returns an error if authentication fails or the API request fails.

Example

let bitget = Bitget::builder()
    .api_key("your-api-key")
    .secret("your-secret")
    .passphrase("your-passphrase")
    .build()?;
bitget.load_markets(false).await?;
let order = bitget.fetch_order("123456789", "BTC/USDT").await?;
println!("Order status: {:?}", order.status);

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

Fetch open orders.

Arguments

• symbol - Optional trading pair symbol. If None, fetches all open orders.
• since - Optional start timestamp in milliseconds.
• limit - Optional limit on number of orders (maximum: 500).

Returns

Returns a vector of open Order structures.

Errors

Returns an error if authentication fails or the API request fails.

Example

let bitget = Bitget::builder()
    .api_key("your-api-key")
    .secret("your-secret")
    .passphrase("your-passphrase")
    .build()?;
bitget.load_markets(false).await?;

// Fetch all open orders
let all_open = bitget.fetch_open_orders(None, None, None).await?;

// Fetch open orders for specific symbol
let btc_open = bitget.fetch_open_orders(Some("BTC/USDT"), None, Some(50)).await?;

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

Fetch closed orders.

Arguments

• symbol - Optional trading pair symbol. If None, fetches all closed orders.
• since - Optional start timestamp in milliseconds.
• limit - Optional limit on number of orders (maximum: 500).

Returns

Returns a vector of closed Order structures.

Errors

Returns an error if authentication fails or the API request fails.

Example

let bitget = Bitget::builder()
    .api_key("your-api-key")
    .secret("your-secret")
    .passphrase("your-passphrase")
    .build()?;
bitget.load_markets(false).await?;

// Fetch closed orders for specific symbol
let closed = bitget.fetch_closed_orders(Some("BTC/USDT"), None, Some(50)).await?;

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<Bitget, Error>

Creates a new Bitget instance.

Arguments

• config - Exchange configuration.

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

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 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<(), Error>

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>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Bitget: '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>>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Bitget: '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, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Bitget: '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>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Bitget: '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>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: 'async_trait,

Fetch closed orders

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

where 'life0: 'async_trait, Bitget: '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>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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 'life0: 'async_trait, Bitget: '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 WsExchange for Bitget

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

where 'life0: 'async_trait, Bitget: 'async_trait,

Connect to the WebSocket server

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

where 'life0: 'async_trait, Bitget: '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<Pin<Box<dyn Stream<Item = Result<Ticker, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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<Pin<Box<dyn Stream<Item = Result<Vec<Ticker>, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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<Pin<Box<dyn Stream<Item = Result<OrderBook, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: 'async_trait,

Watch order book updates

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

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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<Pin<Box<dyn Stream<Item = Result<Ohlcv, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: 'async_trait,

Watch OHLCV candlestick updates

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

where 'life0: 'async_trait, Bitget: '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<Pin<Box<dyn Stream<Item = Result<Order, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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<Pin<Box<dyn Stream<Item = Result<Trade, Error>> + Send>>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Bitget: '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<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Bitget: '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<(), Error>> + Send + 'async_trait>>

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

Unsubscribe from a channel

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

Get list of active subscriptions