Struct BinanceFuturesProvider

pub struct BinanceFuturesProvider { /* private fields */ }

Binance Futures exchange provider implementation

Implementations

impl BinanceFuturesProvider

pub fn new( config: ConnectionConfig, market_type: BinanceFuturesMarketType, ) -> Self

Create a new Binance Futures provider

impl BinanceFuturesProvider

pub const fn name(&self) -> &str

Get provider name

pub const fn venue(&self) -> Venue

Get venue

pub async fn connect(&mut self) -> Result<()>

Connect to WebSocket

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

Disconnect from WebSocket

pub async fn subscribe_orderbook( &mut self, instrument_id: &InstrumentId, depth: usize, ) -> Result<()>

Subscribe to orderbook updates

pub async fn subscribe_trades( &mut self, instrument_id: &InstrumentId, ) -> Result<()>

Subscribe to trade updates

pub async fn unsubscribe_orderbook( &mut self, instrument_id: &InstrumentId, ) -> Result<()>

Unsubscribe from orderbook updates

pub async fn unsubscribe_trades( &mut self, instrument_id: &InstrumentId, ) -> Result<()>

Unsubscribe from trade updates

pub fn is_connected(&self) -> bool

Check if connected

pub fn connection_stats(&self) -> ConnectionStats

Get connection statistics

pub async fn run_with_handler( &mut self, handler: Box<dyn DataHandler + Send + Sync>, ) -> Result<()>

Run with data handler

pub async fn fetch_instruments(&self) -> Result<Vec<Box<dyn Instrument>>>

Fetch available instruments

Trait Implementations

impl Debug for BinanceFuturesProvider

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl HttpClientProvider for BinanceFuturesProvider

fn http_client(&self) -> &Client

Returns a reference to the HTTP client

fn create_http_client(config: &ConnectionConfig) -> Client

Create a new HTTP client with appropriate settings from config

impl MonitorExt for BinanceFuturesProvider

MonitorExt implementation for BinanceFuturesProvider

Provides advanced monitoring capabilities for HFT trading systems

fn get_instrument_metrics<'life0, 'life1, 'async_trait>( &'life0 self, instrument_id: &'life1 InstrumentId, ) -> Pin<Box<dyn Future<Output = Result<InstrumentMetrics>> + Send + 'async_trait>>

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

Retrieves comprehensive real-time metrics for a specific trading instrument

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

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

Retrieves aggregated metrics across all actively monitored instruments

fn register_metrics_collector<'life0, 'async_trait>( &'life0 mut self, _collector: Box<dyn MetricsCollector>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Registers a custom metrics collector for domain-specific monitoring

fn enable_alert<'life0, 'async_trait>( &'life0 mut self, alert_config: AlertConfig, ) -> Pin<Box<dyn Future<Output = Result<AlertHandle>> + Send + 'async_trait>>

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

Enables a real-time alert for specific monitoring conditions

fn disable_alert<'life0, 'async_trait>( &'life0 mut self, _handle: AlertHandle, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Disables an active alert using its handle

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

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

Retrieves the current health status with detailed component diagnostics

fn start_anomaly_detection<'life0, 'async_trait>( &'life0 mut self, _config: AnomalyConfig, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Starts anomaly detection for trading patterns and system behavior

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

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

Stops all active anomaly detection algorithms

fn get_latency_distribution<'life0, 'life1, 'async_trait>( &'life0 self, _instrument_id: &'life1 InstrumentId, ) -> Pin<Box<dyn Future<Output = Result<LatencyDistribution>> + Send + 'async_trait>>

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

Retrieves detailed latency distribution statistics for an instrument

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

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

Exports all metrics in Prometheus exposition format

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

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

Resets all monitoring statistics to their initial state

fn get_trading_metrics<'life0, 'life1, 'async_trait>( &'life0 self, _instrument_id: &'life1 InstrumentId, ) -> Pin<Box<dyn Future<Output = Result<TradingMetrics>> + Send + 'async_trait>>

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

Retrieves advanced trading-specific metrics for an instrument

impl Provider for BinanceFuturesProvider

Provider trait implementation for Binance Futures

type TradeMessage = AggTradeMessage

Exchange-specific raw message type for trades from WebSocket

type DepthMessage = OrderbookMessage

Exchange-specific raw message type for orderbook updates from WebSocket

type InstrumentMessage = Value

Exchange-specific raw message type for instrument info

fn name(&self) -> &'static str

Returns the exchange name as a static String

fn venue(&self) -> Venue

Returns the venue enum value for this provider

fn config(&self) -> &ConnectionConfig

Returns reference to the connection configuration

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

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

Initialize the provider with any necessary setup steps This method should be called before using other methods

fn subscribe_trades<'life0, 'async_trait>( &'life0 self, symbols: SmallVec<[String; 8]>, ) -> Pin<Box<dyn Future<Output = Result<Receiver<Self::TradeMessage>>> + Send + 'async_trait>>

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

Subscribe to trade data stream for multiple symbols Returns a channel receiver for trade messages Uses SmallVec to avoid heap allocations for small numbers of symbols

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

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

Unsubscribe from trade data

fn subscribe_orderbook<'life0, 'async_trait>( &'life0 self, symbols: SmallVec<[String; 8]>, ) -> Pin<Box<dyn Future<Output = Result<Receiver<Self::DepthMessage>>> + Send + 'async_trait>>

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

Subscribe to orderbook depth data for multiple symbols Returns a channel receiver for depth messages Uses SmallVec to avoid heap allocations for small numbers of symbols

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

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

Unsubscribe from orderbook depth data

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

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

Get all available trading instruments from the exchange

fn get_historical_trades<'life0, 'life1, 'async_trait>( &'life0 self, _symbol: &'life1 str, _limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<MarketTrade>>> + Send + 'async_trait>>

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

Get historical trades for a symbol Optionally limit the number of trades returned

fn get_orderbook_snapshot<'life0, 'life1, 'async_trait>( &'life0 self, symbol: &'life1 str, depth: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<OrderBookSnapshot>> + Send + 'async_trait>>

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

Get current orderbook snapshot for a symbol Optionally specify the depth of the orderbook

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

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

Get realtime shared orderbook for a symbol Returns a thread-safe shared orderbook that’s kept up-to-date

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

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

Check if provider is connected to exchange Default implementation returns false - exchanges should override

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

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

Get detailed connection status Default implementation returns Disconnected - exchanges should override

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

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

Get connection statistics for monitoring Default implementation returns empty stats - exchanges should override

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

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

Ping the exchange to keep the connection alive Returns round-trip time in nanoseconds Default implementation returns 0 - exchanges should override

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

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

Reset connection (force reconnect) Default implementation does nothing - exchanges should override

fn get_rate_limits(&self) -> Vec<RateLimit>

Get the exchange-specific rate limits Default implementation returns empty vector - exchanges should override

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

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

Close all connections and clean up resources

fn start_provide_depth<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Receiver<Self::DepthMessage>>> + Send + 'async_trait>>

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

Start providing depth data Returns a receiver for depth messages Default implementation returns error - exchanges should override

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

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

Stop providing depth data Default implementation does nothing

fn start_provide_trade<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Receiver<Self::TradeMessage>>> + Send + 'async_trait>>

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

Start providing trade data Returns a receiver for trade messages Default implementation returns error - exchanges should override

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

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

Stop providing trade data Default implementation does nothing

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

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

Check if provider is operational Returns true if the provider is functioning correctly

fn convert_exchange_timestamp(&self, exchange_timestamp: u64) -> u64

High-performance timestamp conversion method Uses cached timestamp conversions when possible and provides optimized conversion when timestamps are a known format.

fn convert_iso8601_timestamp(&self, iso_timestamp: &str) -> Option<u64>

Convert ISO8601 timestamp String to nanoseconds with caching for frequent values This method should be used for exchanges that provide timestamps as ISO8601 strings such as Coinbase.

fn current_time_nanos(&self) -> u64

Get current time in nanoseconds from the provider’s clock This method uses the shared clock to ensure consistent timekeeping across all parts of the exchange provider.