Struct bybit::ws::Stream

pub struct Stream<'a> {
    pub client: Client<'a>,
}

Fields

client: Client<'a>

Implementations

impl<'a> Stream<'_>

pub async fn ws_ping(&self, private: bool) -> Result<(), BybitError>

Tests for connectivity by sending a ping request to the Bybit server.

Returns

Returns a Result containing a String with the response message if successful,

• private is set to true if the request is for a private endpoint or a BybitError if an error occurs.

pub async fn ws_priv_subscribe<'b, F>( &self, req: Subscription<'_>, handler: F, ) -> Result<(), BybitError>

where F: FnMut(WebsocketEvents) -> Result<(), BybitError> + 'static + Send,

pub async fn ws_subscribe<'b, F>( &self, req: Subscription<'_>, category: Category, handler: F, ) -> Result<(), BybitError>

where F: FnMut(WebsocketEvents) -> Result<(), BybitError> + 'static + Send,

pub fn build_subscription(action: Subscription<'_>) -> String

pub fn build_trade_subscription( orders: RequestType<'_>, recv_window: Option<u64>, ) -> String

pub async fn ws_orderbook( &self, subs: Vec<(i32, &str)>, category: Category, sender: UnboundedSender<OrderBookUpdate>, ) -> Result<(), BybitError>

Subscribes to the specified order book updates and handles the order book events

Arguments

• subs - A vector of tuples containing the order book ID and symbol
• category - The category of the order book

Example

use your_crate_name::Category;
let subs = vec![(1, "BTC"), (2, "ETH")];

pub async fn ws_trades( &self, subs: Vec<&str>, category: Category, sender: UnboundedSender<WsTrade>, ) -> Result<(), BybitError>

This function subscribes to the specified trades and handles the trade events.

Arguments

• subs - A vector of trade subscriptions
• category - The category of the trades

Example

use your_crate_name::Category;
let subs = vec!["BTCUSD", "ETHUSD"];
let category = Category::Linear;
ws_trades(subs, category);

pub async fn ws_tickers( &self, subs: Vec<&str>, category: Category, sender: UnboundedSender<Tickers>, ) -> Result<(), BybitError>

Subscribes to ticker events for the specified symbols and category.

Arguments

• subs - A vector of symbols for which ticker events are subscribed.
• category - The category for which ticker events are subscribed.

Examples

use your_crate_name::Category;
let subs = vec!["BTCUSD", "ETHUSD"];
let category = Category::Linear;
let sender = UnboundedSender<Tickers>;
ws_tickers(subs, category, sender);

pub async fn ws_liquidations( &self, subs: Vec<&str>, category: Category, sender: UnboundedSender<LiquidationData>, ) -> Result<(), BybitError>

pub async fn ws_klines( &self, subs: Vec<(&str, &str)>, category: Category, sender: UnboundedSender<WsKline>, ) -> Result<(), BybitError>

pub async fn ws_position( &self, cat: Option<Category>, sender: UnboundedSender<PositionData>, ) -> Result<(), BybitError>

pub async fn ws_executions( &self, cat: Option<Category>, sender: UnboundedSender<ExecutionData>, ) -> Result<(), BybitError>

pub async fn ws_fast_exec( &self, sender: UnboundedSender<FastExecData>, ) -> Result<(), BybitError>

pub async fn ws_orders( &self, cat: Option<Category>, sender: UnboundedSender<OrderData>, ) -> Result<(), BybitError>

pub async fn ws_wallet( &self, sender: UnboundedSender<WalletData>, ) -> Result<(), BybitError>

pub async fn ws_trade_stream<'b, F>( &self, req: UnboundedReceiver<RequestType<'_>>, handler: F, ) -> Result<(), BybitError>

where F: FnMut(WebsocketEvents) -> Result<(), BybitError> + 'static + Send, 'a: 'static,

pub async fn event_loop<'b, H>( stream: WebSocketStream<MaybeTlsStream<TcpStream>>, handler: H, order_sender: Option<UnboundedReceiver<RequestType<'_>>>, ) -> Result<(), BybitError>

where H: WebSocketHandler,

Trait Implementations

impl<'a> Bybit<'a> for Stream<'a>

fn new( api_key: Option<Cow<'_, str>>, secret_key: Option<Cow<'_, str>>, ) -> Stream<'a>

Creates a new instance of the module with default configuration.

fn new_with_config( config: &Config<'_>, api_key: Option<Cow<'_, str>>, secret_key: Option<Cow<'_, str>>, ) -> Stream<'a>

Creates a new instance of the module with custom configuration.

impl<'a> Clone for Stream<'a>

fn clone(&self) -> Stream<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.