Struct DepthCacheManager 

pub struct DepthCacheManager { /* private fields */ }

Manages a local order book cache with WebSocket updates.

This manager follows Binance’s recommended approach for maintaining a local order book:

1. Open a WebSocket connection for depth updates
2. Buffer incoming events
3. Fetch a REST API snapshot
4. Apply buffered events that are newer than the snapshot
5. Continue applying real-time updates

Example

use binance_api_client::Binance;
use binance_api_client::websocket::{DepthCacheManager, DepthCacheConfig};

let client = Binance::new_unauthenticated()?;
let config = DepthCacheConfig::default();
let mut manager = DepthCacheManager::new(client, "BTCUSDT", config).await?;

// Wait for initial sync
manager.wait_for_sync().await?;

// Get current order book
let cache = manager.get_cache().await;
println!("Best bid: {:?}", cache.best_bid());
println!("Best ask: {:?}", cache.best_ask());

// Receive updates
while let Some(cache) = manager.next().await {
    println!("Mid price: {:?}", cache.mid_price());
}

Implementations

impl DepthCacheManager

pub async fn new( client: Binance, symbol: &str, config: DepthCacheConfig, ) -> Result<Self>

Create a new depth cache manager.

This will start the WebSocket connection and begin syncing the order book.

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

Wait for the cache to be synchronized.

pub async fn get_cache(&self) -> DepthCache

Get the current depth cache.

pub async fn state(&self) -> DepthCacheState

Get the current state of the manager.

pub async fn next(&mut self) -> Option<DepthCache>

Receive the next cache update.

pub fn stop(&self)

Stop the depth cache manager.

pub fn symbol(&self) -> &str

Get the symbol being tracked.