Struct MarketStatsCache 

pub struct MarketStatsCache {
    stats: Arc<RwLock<HashMap<String, InstrumentStats>>>,
    portfolio_service: Arc<dyn PortfolioService + Send + Sync>,
}

Cache for market statistics (volume_24h and open_interest)

Fields

stats: Arc<RwLock<HashMap<String, InstrumentStats>>>

Per-symbol volume statistics

portfolio_service: Arc<dyn PortfolioService + Send + Sync>

Reference to portfolio service for open interest calculation

Implementations

impl MarketStatsCache

pub fn new(portfolio_service: Arc<dyn PortfolioService + Send + Sync>) -> Self

Create a new MarketStatsCache.

Arguments

• portfolio_service - The portfolio service to derive open interest from

pub async fn initialize( self: Arc<Self>, event_bus: Arc<dyn EventBusTrait>, ) -> Result<()>

Initialize the cache and start listening to events (legacy, no shutdown support).

pub async fn initialize_with_shutdown( self: Arc<Self>, event_bus: Arc<dyn EventBusTrait>, shutdown_rx: Receiver<()>, ) -> Result<()>

Initialize the cache with shutdown support.

This method starts the event listener for fills. For better startup performance, use initialize_with_backfill which loads last 24h from DB first.

pub async fn initialize_with_backfill( self: Arc<Self>, diesel_db: &dyn AnalyticsReader, event_bus: Arc<dyn EventBusTrait>, shutdown_rx: Receiver<()>, ) -> Result<()>

Initialize with DB backfill for the last 24 hours of fills.

This is the recommended initialization method (Phase 3c):

1. Load last 24h of fills from database
2. Then subscribe to event bus for real-time updates

This avoids replaying all historical fills.

async fn backfill_from_db( &self, diesel_db: &dyn AnalyticsReader, ) -> Result<usize>

async fn start_event_listeners_with_shutdown( self: Arc<Self>, event_bus: Arc<dyn EventBusTrait>, shutdown_rx: Receiver<()>, ) -> Result<()>

Start event listeners for fill events.

async fn handle_fill(&self, fill: &Fill)

Handle a fill event to update volume statistics.

pub async fn get_volume_24h(&self, symbol: &str) -> Decimal

Get the 24-hour volume for a symbol.

pub async fn get_open_interest(&self, symbol: &str) -> Decimal

Get the open interest for a symbol.

Open interest is calculated as SUM(ABS(amount)) / 2 across all accounts. Division by 2 because each position is double-counted (taker + maker sides).

pub async fn get_stats(&self, symbol: &str) -> (Decimal, Decimal)

Get both volume_24h and open_interest for a symbol.

pub async fn get_all_stats(&self) -> HashMap<String, (Decimal, Decimal)>

Get stats for all tracked symbols.

Trait Implementations

impl MarketStatsCacheReader for MarketStatsCache

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

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