Struct EngineMmpState 

pub struct EngineMmpState {
    pub enabled: bool,
    pub interval_ms: i64,
    pub frozen_time_ms: i64,
    pub qty_limit: Option<f64>,
    pub delta_limit: Option<f64>,
    pub vega_limit: Option<f64>,
    pub fills: VecDeque<MmpFillRecord>,
    pub cumulative_qty: u64,
    pub cumulative_delta: f64,
    pub cumulative_vega: f64,
    pub frozen_until: Option<u64>,
}

Engine-internal MMP state for a single (wallet, currency) pair.

Maintains a rolling window of recent fills, cumulative greek accumulators, and a timed freeze mechanism. When cumulative exposure within the window exceeds any configured limit, the state freezes and rejects all subsequent fills until frozen_until has passed.

Fields

Configuration fields are set by EngineCommand::MmpConfigUpdate:

• enabled – Whether MMP is active. When disabled, process_fill is a no-op.
• interval_ms – Rolling window duration in milliseconds.
• frozen_time_ms – Duration of freeze after a limit breach, in milliseconds.
• qty_limit – Maximum cumulative quantity within the window. None means unlimited.
• delta_limit – Maximum absolute cumulative delta. None means unlimited.
• vega_limit – Maximum absolute cumulative vega. None means unlimited.

Runtime state (managed internally):

• fills – Rolling window of MmpFillRecord entries, ordered by timestamp.
• cumulative_qty – Sum of quantity across all fills in the window.
• cumulative_delta – Sum of delta across all fills in the window.
• cumulative_vega – Sum of vega across all fills in the window.
• frozen_until – If Some(t), MMP is frozen until timestamp t (exclusive).

Fields

enabled: bool

Whether MMP is active for this wallet/currency pair.

interval_ms: i64

Rolling window duration in milliseconds.

frozen_time_ms: i64

Freeze duration in milliseconds after a limit breach.

qty_limit: Option<f64>

Maximum cumulative quantity within the window. None disables this limit.

delta_limit: Option<f64>

Maximum absolute cumulative delta within the window. None disables this limit.

vega_limit: Option<f64>

Maximum absolute cumulative vega within the window. None disables this limit.

fills: VecDeque<MmpFillRecord>

Rolling window of fill records, ordered by ascending timestamp.

cumulative_qty: u64

Sum of fill quantities currently in the window.

cumulative_delta: f64

Sum of fill deltas currently in the window.

cumulative_vega: f64

Sum of fill vegas currently in the window.

frozen_until: Option<u64>

If Some(t), all fills are rejected until current_time_ms >= t.

Implementations

impl EngineMmpState

pub fn new( enabled: bool, interval_ms: i64, frozen_time_ms: i64, qty_limit: Option<f64>, delta_limit: Option<f64>, vega_limit: Option<f64>, ) -> EngineMmpState

Create a new MMP state with the given configuration.

The state starts unfrozen with an empty fill window and zeroed accumulators.

Parameters

• enabled – Whether MMP is active. Pass false to create a disabled state.
• interval_ms – Rolling window duration in milliseconds.
• frozen_time_ms – How long to freeze after a breach, in milliseconds.
• qty_limit – Max cumulative quantity, or None for unlimited.
• delta_limit – Max absolute cumulative delta, or None for unlimited.
• vega_limit – Max absolute cumulative vega, or None for unlimited.

pub fn is_frozen(&self, current_time_ms: u64) -> bool

Check whether MMP is currently frozen.

Returns true if frozen_until is set and current_time_ms has not yet reached it. The freeze expires at exactly frozen_until (i.e., the comparison is strict less-than).

This method is pure. It does not modify state or advance time.

pub fn evict_old_fills(&mut self, current_time_ms: u64)

Evict fills that have fallen outside the rolling window.

Removes all fills from the front of the deque whose timestamp_ms is older than current_time_ms - interval_ms. Each evicted fill’s greek contributions are subtracted from the cumulative accumulators using saturating arithmetic for quantity.

This is called automatically at the start of process_fill, but can also be called independently if you need to inspect the window state at a point in time.

pub fn process_fill( &mut self, record: MmpFillRecord, current_time_ms: u64, ) -> Result<(), String>

Process a fill through MMP, returning Ok(()) if accepted or Err if rejected.

Flow

1. If MMP is disabled (enabled == false), return Ok(()) immediately.
2. If currently frozen, return Err without modifying state.
3. Evict fills outside the rolling window via evict_old_fills.
4. Add the fill’s contributions to cumulative accumulators.
5. Push the fill record into the window deque.
6. Check each enabled limit (quantity, delta, vega). If any limit is breached, set frozen_until = current_time_ms + frozen_time_ms and return Err.
7. If all limits pass, return Ok(()).

Errors

Returns an error string describing which limit was breached, or that MMP is currently frozen. The fill’s contributions are already added to the accumulators before the limit check, so a breaching fill is counted in the window even though it triggers the freeze.

pub fn reset(&mut self)

Reset MMP state, clearing all fills and unfreezing.

Empties the fill window, zeroes all cumulative accumulators, and clears the frozen_until timestamp. The configuration fields (enabled, interval_ms, frozen_time_ms, limits) are not changed.

Typically called when a market maker explicitly requests an MMP reset via the API after reviewing their risk.

Trait Implementations

impl Clone for EngineMmpState

fn clone(&self) -> EngineMmpState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EngineMmpState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EngineMmpState

fn deserialize<__D>( __deserializer: __D, ) -> Result<EngineMmpState, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EngineMmpState

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.