Struct BinanceExchange

pub struct BinanceExchange { /* private fields */ }

Binance exchange implementation providing order execution and market data access

Implementations

impl BinanceExchange

pub fn rest_client(&self) -> &BinanceRestClient

Get direct access to REST client for performance-critical operations

pub const fn websocket_client(&self) -> &BinanceWebSocketClient

Get direct access to WebSocket client for performance-critical operations

pub fn create_rest_client( api_key: String, secret_key: String, ) -> BinanceRestClient

Create standalone REST client with shared auth

pub fn create_websocket_client( api_key: String, secret_key: String, ) -> BinanceWebSocketClient

Create standalone WebSocket client with shared auth

pub fn new(api_key: String, secret_key: String) -> Self

Create a new Binance exchange adapter

pub fn new_with_config( api_key: String, secret_key: String, config: BinanceConfig, ) -> Self

Create a new Binance exchange adapter with custom major symbols

pub fn new_ed25519(api_key: String, private_key: String) -> Result<Self>

Create a new Binance exchange adapter with Ed25519 authentication

pub fn new_ed25519_with_config( api_key: String, private_key: String, config: BinanceConfig, ) -> Result<Self>

Create a new Binance exchange adapter with Ed25519 authentication and custom configuration

pub async fn place_oco_order( &self, symbol: &str, side: OrderSide, quantity: Decimal, above_type: &str, below_type: &str, above_price: Option<Decimal>, below_price: Option<Decimal>, above_stop_price: Option<Decimal>, below_stop_price: Option<Decimal>, report_tx: Sender<ExecutionReport>, ) -> Result<()>

Place an OCO (One-Cancels-Other) order

Arguments

• symbol - Trading symbol (e.g., “BTCUSDT”)
• side - Order side (Buy/Sell)
• quantity - Order quantity
• above_type - Order type for above price (STOP_LOSS_LIMIT, LIMIT_MAKER, etc.)
• below_type - Order type for below price (STOP_LOSS, STOP_LOSS_LIMIT, etc.)
• above_price - Limit price for above order
• below_price - Limit price for below order
• above_stop_price - Stop price for above order
• below_stop_price - Stop price for below order
• report_tx - Channel to send execution reports

pub async fn place_sor_order( &self, symbol: &str, side: OrderSide, order_type: OrderType, quantity: Decimal, price: Option<Decimal>, time_in_force: Option<TimeInForce>, report_tx: Sender<ExecutionReport>, ) -> Result<()>

Place a SOR (Smart Order Routing) order

Arguments

• symbol - Trading symbol (e.g., “BTCUSDT”)
• side - Order side (Buy/Sell)
• order_type - Order type (Limit/Market)
• quantity - Order quantity
• price - Order price (required for LIMIT orders)
• time_in_force - Time in force (GTC/IOC/FOK)
• report_tx - Channel to send execution reports

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

Place multiple orders concurrently

Arguments

• orders - Vector of orders to place
• report_tx - Channel to send execution reports

Returns

• Result<BatchResult<()>> - Detailed result with per-order status and errors

pub async fn get_sor_configuration(&self) -> Result<Vec<OwnedValue>>

Get SOR configuration for available symbols

Trait Implementations

impl Clone for BinanceExchange

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 BinanceExchange

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