Struct MmpCache 

pub struct MmpCache {
    configs: Arc<RwLock<HashMap<(WalletAddress, String), MmpConfigRecord>>>,
    state: Arc<RwLock<HashMap<WalletAddress, WalletMmpState>>>,
    db: Arc<dyn MmpConfigWriter>,
    greeks_cache: Arc<GreeksCache>,
}

Main MMP cache for tracking fills and checking limits

Fields

configs: Arc<RwLock<HashMap<(WalletAddress, String), MmpConfigRecord>>>

MMP configurations indexed by (wallet_address, currency)

state: Arc<RwLock<HashMap<WalletAddress, WalletMmpState>>>

Per-wallet state tracking

db: Arc<dyn MmpConfigWriter>

Database handler for persistence

greeks_cache: Arc<GreeksCache>

Greeks cache for calculating delta and vega

Implementations

impl MmpCache

pub fn new( db: Arc<dyn MmpConfigWriter>, greeks_cache: Arc<GreeksCache>, ) -> Result<Self>

Create a new MMP cache

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

Load all MMP configs from database

pub async fn set_config(&self, config: MmpConfig) -> Result<()>

Set or update MMP config

pub async fn get_config( &self, wallet: &WalletAddress, currency: &str, ) -> Option<MmpConfig>

Get MMP config for wallet and currency

pub async fn is_mmp_enabled( &self, wallet: &WalletAddress, currency: &str, ) -> bool

Fast path: Check if MMP is enabled for wallet and currency Returns true if MMP config exists and is enabled, false otherwise This is faster than calling process_fill() for wallets without MMP

pub async fn get_configs_for_wallet( &self, wallet: &WalletAddress, ) -> Vec<MmpConfig>

Get all MMP configs for a wallet

pub async fn delete_config( &self, wallet: &WalletAddress, currency: &str, ) -> Result<()>

Delete (disable) MMP config

pub async fn reset_mmp(&self, wallet: &WalletAddress, currency: &str)

Reset MMP state for a specific currency (clear fills and unfreeze)

pub async fn is_frozen( &self, wallet: &WalletAddress, currency: &str, current_time: u64, ) -> bool

Check if wallet+currency is currently frozen

pub async fn process_fill( &self, wallet: &WalletAddress, currency: &str, fill: &Fill, current_time: u64, ) -> Result<(), String>

Process a fill and check if MMP limits are triggered Returns Ok(()) if limits not exceeded, Err with reason if triggered

pub fn start(&self)

Start the automatic eviction task (legacy, no shutdown support). This spawns a background task that periodically evicts old fills from all currency windows. For graceful shutdown support, use start_with_shutdown instead.

pub fn start_with_shutdown(&self, shutdown_rx: Receiver<()>) -> JoinHandle<()>

Start the automatic eviction task with shutdown support. This spawns a background task that periodically evicts old fills from all currency windows. The task will exit gracefully when the shutdown signal is received.

async fn calculate_fill_metrics(&self, fill: &Fill) -> Result<(f64, f64)>

Calculate delta and vega for a fill using the Greeks cache Returns error if Greeks data is not available for the symbol

Trait Implementations

impl MmpCacheApi for MmpCache

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

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

fn get_config<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, wallet: &'life1 WalletAddress, currency: &'life2 str, ) -> Pin<Box<dyn Future<Output = Option<MmpConfigRecord>> + Send + 'async_trait>>

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

fn get_configs_for_wallet<'life0, 'life1, 'async_trait>( &'life0 self, wallet: &'life1 WalletAddress, ) -> Pin<Box<dyn Future<Output = Vec<MmpConfigRecord>> + Send + 'async_trait>>

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

fn delete_config<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, wallet: &'life1 WalletAddress, currency: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

fn reset_mmp<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, wallet: &'life1 WalletAddress, currency: &'life2 str, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

impl Service for MmpCache

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

fn owner(&self) -> ServiceOwner

fn run<'async_trait>( self: Arc<Self>, shutdown: ShutdownRx, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait,

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

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