Struct MarginManager 

pub struct MarginManager {
    pub span_margin_service: SpanMarginService,
    pub standard_margin_service: StandardMarginService,
}

Margin manager encapsulating SPAN and Standard margin services.

Methods borrow &EngineDeps for access to caches, portfolio service, etc.

Fields

span_margin_service: SpanMarginService

SPAN scenario-based margin service (Portfolio mode).

standard_margin_service: StandardMarginService

Deribit-style linear margin service (Standard mode).

Implementations

impl MarginManager

pub fn new(config: &Config) -> Self

Create a new MarginManager from config.

pub fn new_with_vol_oracle( config: &Config, vol_oracle: Option<SharedVolOracle>, ) -> Self

pub fn check_margin_for_order( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, order_info: &OrderInfo, order_index: &EngineOrderIndex, ) -> Result<(), String>

Unified margin check for both option and perp orders.

Branches on margin mode:

• Portfolio mode: SPAN-based scenario margin
• Standard mode: Deribit-style linear margin

pub fn check_margin_for_orders( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, proposed_orders: &[OrderInfo], order_index: &EngineOrderIndex, ) -> Result<(), String>

Margin check for a batch of orders that must be accepted or rejected together, e.g. a multi-leg RFQ where leg N-1 hedges leg N and the combination is healthy even though individual legs would not pass margin in isolation.

Branches on the wallet’s configured margin mode, matching the single-order admission path. RFQ is an immediately executed product, so the Standard path checks the post-execution account state rather than treating the proposed legs as resting open orders.

pub fn check_margin_for_quote_provider_orders( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, proposed_orders: &[OrderInfo], order_index: &EngineOrderIndex, ) -> Result<(), String>

RFQ quote-provider margin check.

The RFQ gateway only sends active registered quote providers to this engine path. Let those providers open Standard-margin shorts while keeping the normal Standard short ban for takers and orderbook orders.

fn check_margin_for_orders_with_standard_short_bypass( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, proposed_orders: &[OrderInfo], order_index: &EngineOrderIndex, allow_standard_short_bypass: bool, ) -> Result<(), String>

pub fn get_margin_mode( &self, deps: &EngineDeps, wallet: &WalletAddress, ) -> Result<MarginMode, String>

Get the margin mode for a wallet.

pub fn get_risk_account( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, ) -> Result<Account, String>

Build a risk-ready Account from engine balances and positions.

pub fn build_account_for_risk( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, _balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, ) -> Result<Account, String>

Build a risk account including open orders when PM is enabled.

pub fn get_span_margin_for_wallet( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, ) -> Result<Option<MarginDetails>, String>

Get SPAN margin details for a wallet’s executed state.

fn build_spot_prices_for_balance( &self, deps: &EngineDeps, balance: &PortfolioBalance, ) -> HashMap<String, f64>

Build spot prices map for a portfolio balance.

pub fn get_spot_price_for_margin( &self, deps: &EngineDeps, underlying: &str, ) -> Result<f64, String>

Get spot price for an underlying, returning an error if unavailable.

pub fn fetch_open_orders( &self, order_index: &EngineOrderIndex, wallet: &WalletAddress, ) -> Vec<ApiOrder>

Fetch all open orders for a wallet from the in-process order index.

pub fn create_simulated_order( &self, order_info: &OrderInfo, wallet: &WalletAddress, ) -> ApiOrder

Create a simulated order from OrderInfo for margin checking.

fn check_margin_portfolio( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, order_info: &OrderInfo, order_index: &EngineOrderIndex, ) -> Result<(), String>

Portfolio margin check using SPAN scenarios.

fn check_margin_standard( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, order_info: &OrderInfo, order_index: &EngineOrderIndex, ) -> Result<(), String>

Standard margin check using Deribit-style linear margin.

fn check_margin_standard_for_orders( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, proposed_orders: &[OrderInfo], order_index: &EngineOrderIndex, allow_standard_short_bypass: bool, ) -> Result<(), String>

fn reject_standard_net_short_order( &self, engine_positions: &EnginePositionMap, wallet: &WalletAddress, order_info: &OrderInfo, order_index: &EngineOrderIndex, ) -> Result<(), String>

fn reject_standard_net_short_orders( &self, engine_positions: &EnginePositionMap, wallet: &WalletAddress, proposed_orders: &[OrderInfo], order_index: &EngineOrderIndex, ) -> Result<(), String>

fn add_open_sell_orders_to_standard_account( &self, deps: &EngineDeps, account: &mut StandardAccount, wallet: &WalletAddress, order_index: &EngineOrderIndex, ) -> Result<(), String>

fn build_hypothetical_account_for_orders( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, proposed_orders: &[OrderInfo], order_index: &EngineOrderIndex, ) -> Result<Account, String>

Build a hypothetical Account representing the state if every proposed_order fills on top of the wallet’s current executed state plus its existing open orders. Used by check_margin_for_orders to score multi-leg RFQ commands as a single portfolio snapshot.

fn build_hypothetical_account_for_order( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, order_info: &OrderInfo, order_index: &EngineOrderIndex, ) -> Result<Account, String>

Build a hypothetical Account representing the state if the proposed order fills.

fn apply_order_to_account( &self, deps: &EngineDeps, account: &mut Account, order: &ApiOrder, spot_prices: &HashMap<String, f64>, ) -> Result<(), String>

Apply an order as a hypothetical fill to an account’s portfolio.

pub fn run_margin_on_account( &self, account: &Account, ) -> Result<Option<MarginDetails>, String>

Run margin calculation on an Account using the MarginService.

pub fn run_margin_on_account_with_deps( &self, account: &Account, deps: &EngineDeps, ) -> Result<Option<MarginDetails>, String>

fn run_margin_on_account_at( &self, account: &Account, now_ts: i64, ) -> Result<Option<MarginDetails>, String>

pub fn check_tier_restrictions( &self, deps: &EngineDeps, engine_positions: &EnginePositionMap, balance_ledger: &HashMap<WalletAddress, Decimal>, wallet: &WalletAddress, order_info: &OrderInfo, order_index: &EngineOrderIndex, ) -> Result<(), String>

Check tier restrictions (tier1 can only go long).