Struct WebSocketConnection 

pub struct WebSocketConnection { /* private fields */ }

Represents an active WebSocket connection to the HTX API.

The WebSocketConnection encapsulates the WebSocket stream and provides methods for subscribing to ticker streams, receiving messages, handling ping/pong keep-alive, and closing the connection gracefully.

Examples

use bothan_htx::api::websocket::WebSocketConnection;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Assuming you have a connection
    // let mut connection = /* ... */;
    // connection.subscribe_ticker("btcusdt").await?;
    Ok(())
}

Implementations

impl WebSocketConnection

pub fn new(ws_stream: WebSocketStream<MaybeTlsStream<TcpStream>>) -> Self

Creates a new WebSocketConnection instance.

Parameters

• ws_stream: The WebSocket stream for communication with the HTX API

Returns

A new WebSocketConnection instance.

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

Subscribes to ticker updates for a single symbol.

This method sends a subscription request to the HTX WebSocket API for the specified symbol. The symbol is formatted into the HTX channel format (e.g., “market.btcusdt.ticker”).

Parameters

• symbol: The trading pair symbol to subscribe to (e.g., “btcusdt”)

Returns

Returns a Result indicating success or failure of the subscription request.

Errors

Returns a tungstenite::Error if the subscription request fails.

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

Unsubscribes from ticker updates for a single symbol.

This method sends an unsubscription request to the HTX WebSocket API for the specified symbol. The symbol is formatted into the HTX channel format (e.g., “market.btcusdt.ticker”).

Parameters

• symbol: The trading pair symbol to unsubscribe from (e.g., “btcusdt”)

Returns

Returns a Result indicating success or failure of the unsubscription request.

Errors

Returns a tungstenite::Error if the unsubscription request fails.

pub async fn send_pong(&mut self, pong: u64) -> Result<(), Error>

Sends a Pong message in response to a Ping message.

This method sends a pong response to maintain the WebSocket connection keep-alive. The pong value should match the ping value received from the server.

Parameters

• pong: The pong value to send (typically echoing the ping value received)

Returns

Returns a Result indicating success or failure of sending the pong message.

Errors

Returns a tungstenite::Error if the pong message cannot be sent.

pub async fn next(&mut self) -> Option<Result<Response, Error>>

Receives the next message from the WebSocket connection.

This method listens for incoming WebSocket messages and processes them. HTX sends gzip-compressed binary messages, which are automatically decompressed and parsed into Response types.

Returns

Returns an Option<Result<Response, Error>> where:

• Some(Ok(response)) contains a parsed response
• Some(Err(error)) contains a parsing or I/O error
• None indicates the connection is closed or no message is available

pub async fn close(&mut self) -> Result<(), Error>

Closes the WebSocket connection gracefully.

This method sends a close frame to the WebSocket server and waits for the connection to close.

Returns

Returns a Result indicating success or failure of closing the connection.

Errors

Returns a tungstenite::Error if the connection cannot be closed properly.

Trait Implementations

impl AssetInfoProvider for WebSocketConnection

fn subscribe<'life0, 'life1, 'async_trait>( &'life0 mut self, ids: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<(), Self::SubscriptionError>> + Send + 'async_trait>>

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

Subscribes to asset information updates for the given list of asset IDs.

This method sends subscription requests to the HTX WebSocket API for each asset ID. Each asset ID is formatted into the HTX channel format before being sent.

Parameters

• ids: A slice of asset identifiers to subscribe to

Returns

Returns a Result indicating success or failure of the subscription requests.

Errors

Returns a tungstenite::Error if any subscription request fails.

fn next<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Option<Result<Data, Self::ListeningError>>> + Send + 'async_trait>>

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

Processes the next message from the WebSocket stream.

This method handles incoming messages from the HTX WebSocket API, including:

• Market data updates (converted to AssetInfo)
• Ping messages (responded to with pong)
• Error messages (logged as warnings)
• Other message types (ignored)

Returns

Returns an Option<Result<Data, ListeningError>> where:

• Some(Ok(data)) contains processed asset data or ping information
• Some(Err(error)) contains a processing error
• None indicates no message is available

fn try_close<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait,

Attempts to close the WebSocket connection gracefully.

This method spawns a background task to close the connection, ensuring that the close operation doesn’t block the current thread.

type SubscriptionError = Error

The type returned in the event of a subscription failure.

type ListeningError = ListeningError

The type returned in the event of a message reception failure.