Struct BinanceWebSocketTrader

pub struct BinanceWebSocketTrader { /* private fields */ }

High-performance WebSocket-only trading client for Binance

Provides ultra-low latency order execution using WebSocket API exclusively. Includes connection management, authentication, rate limiting, and comprehensive metrics.

Implementations

impl BinanceWebSocketTrader

pub fn is_authenticated(&self) -> bool

Check if authenticated and ready for operations

pub const fn metrics(&self) -> &Arc<ConnectionMetrics>

Get connection metrics

pub fn get_connection_health(&self) -> ConnectionHealth

Get detailed connection health information Returns a struct with current connection status, timing information, and metrics

pub fn new( auth: Arc<BinanceAuth>, position_manager: Arc<dyn PositionManager>, ) -> Self

Create a new WebSocket-only trading client

pub fn new_testnet( auth: Arc<BinanceAuth>, position_manager: Arc<dyn PositionManager>, ) -> Self

Create a new WebSocket-only trading client for testnet

pub async fn connect(&self, report_tx: Sender<ExecutionReport>) -> Result<()>

Connect to Binance WebSocket API

pub async fn handle_account_update( json: &JsonValue, position_manager: &Arc<dyn PositionManager>, )

Handle account update events from user data stream

pub fn parse_position_update( position_json: &JsonValue, event_time: u64, _transaction_time: u64, ) -> Option<PositionUpdate>

Parse position update from ACCOUNT_UPDATE event

pub async fn place_batch_orders( &self, orders: Vec<Order>, report_tx: Sender<ExecutionReport>, ) -> Result<()>

Place batch orders via WebSocket API (up to 50 orders)

This method ensures rate limiting compliance (300 orders/10 seconds) and uses concurrent execution for optimal performance.

Returns Ok(()) if all orders succeed, or an error with details about failed orders

pub async fn place_order( &self, order: Order, report_tx: Sender<ExecutionReport>, ) -> Result<()>

Place order via WebSocket API

pub fn get_rate_limit_status(&self) -> (usize, usize)

Get current rate limit status

pub async fn cancel_order( &self, order_id: SmartString, report_tx: Sender<ExecutionReport>, ) -> Result<()>

Cancel order via WebSocket API

pub async fn modify_order( &self, params: ModifyOrderParams, report_tx: Sender<ExecutionReport>, ) -> Result<()>

Modify order via WebSocket API (cancel and replace)

pub async fn send_ping(&self) -> Result<()>

Send JSON ping to check connection

pub fn is_connected(&self) -> bool

Check if connected

pub async fn reconnect(&self, report_tx: Sender<ExecutionReport>) -> Result<()>

Attempt to reconnect WebSocket (can be called by external monitoring tasks) Note: This will start a new auto-reconnection monitor, so use sparingly

pub async fn disconnect(&self) -> Result<()>

Gracefully disconnect from WebSocket

Trait Implementations

impl Clone for BinanceWebSocketTrader

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Exchange for BinanceWebSocketTrader

fn venue(&self) -> Venue

Returns the venue this exchange connects to

fn place_order<'life0, 'async_trait>( &'life0 self, order: Order, report_tx: Sender<ExecutionReport>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Places a new order on the exchange

fn cancel_order<'life0, 'async_trait>( &'life0 self, order_id: SmartString, report_tx: Sender<ExecutionReport>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Cancels an existing order

fn modify_order<'life0, 'async_trait>( &'life0 self, order_id: SmartString, new_price: Option<Decimal>, new_quantity: Option<Decimal>, report_tx: Sender<ExecutionReport>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Modifies an existing order

fn cancel_all_orders<'life0, 'async_trait>( &'life0 self, instrument_id: Option<InstrumentId>, report_tx: Sender<ExecutionReport>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Cancels all open orders, optionally filtered by instrument

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

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

Retrieves the status of an order

fn connect<'life0, 'async_trait>( &'life0 self, report_sender: Sender<ExecutionReport>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Connects to the exchange

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

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

Disconnects from the exchange

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

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

Checks if connected to the exchange

fn get_instruments<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<SmallVec<[InstrumentId; 32]>>> + Send + 'async_trait>>

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

Gets a list of instruments supported by this exchange

fn send_fix_message<'life0, 'async_trait>( &'life0 self, message: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Sends a FIX message to the exchange

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

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

Receives a FIX message from the exchange