Struct LiquidationWatcher 

pub struct LiquidationWatcher {

    cache: Arc<LiquidationCache>,
    portfolio_service: Arc<dyn PortfolioService + Send + Sync>,
    tier_cache: Option<Arc<TierCache>>,
    span_margin_service: Arc<SpanMarginService>,
    standard_margin_service: Arc<StandardMarginService>,
    risk_account_builder: Option<Arc<RiskAccountBuilder>>,
    standard_account_builder: Option<Arc<StandardAccountBuilder>>,
    quote_provider: Option<Arc<dyn QuoteProvider>>,
    greeks_cache: Option<Arc<GreeksCache>>,
    order_snapshot: Option<Arc<dyn OrderSnapshotProvider>>,
    order_sender: Option<Sender<UnifiedEngineRequest>>,
    event_sender: Option<UnboundedSender<EngineMessage>>,
    executor: Option<Arc<LiquidationExecutor>>,
    config: LiquidationWatcherConfig,
}

Liquidation watcher background task.

Monitors accounts for margin health and triggers liquidation state transitions.

Fields

cache: Arc<LiquidationCache>

Liquidation state cache.

portfolio_service: Arc<dyn PortfolioService + Send + Sync>

Executed portfolio state used for liquidation health and sizing.

tier_cache: Option<Arc<TierCache>>

Tier cache for margin mode lookup.

span_margin_service: Arc<SpanMarginService>

SPAN margin service for portfolio margin accounts.

standard_margin_service: Arc<StandardMarginService>

Standard margin service.

risk_account_builder: Option<Arc<RiskAccountBuilder>>

Risk account builder for portfolio margin.

standard_account_builder: Option<Arc<StandardAccountBuilder>>

Standard account builder for standard margin.

quote_provider: Option<Arc<dyn QuoteProvider>>

Quote provider for liquidation pricing (BBO from orderbook).

greeks_cache: Option<Arc<GreeksCache>>

Greeks cache for theoretical price fallback when BBO unavailable.

order_snapshot: Option<Arc<dyn OrderSnapshotProvider>>

Open-order snapshot provider for cancel/reprice decisions.

order_sender: Option<Sender<UnifiedEngineRequest>>

Order sender for backend-generated partial liquidation orders.

event_sender: Option<UnboundedSender<EngineMessage>>

Event sender for publishing state changes.

executor: Option<Arc<LiquidationExecutor>>

Liquidation executor for onchain calls.

config: LiquidationWatcherConfig

Configuration.

Implementations

impl LiquidationWatcher

pub fn new( cache: Arc<LiquidationCache>, portfolio_service: Arc<dyn PortfolioService + Send + Sync>, tier_cache: Arc<TierCache>, span_margin_service: Arc<SpanMarginService>, standard_margin_service: Arc<StandardMarginService>, config: LiquidationWatcherConfig, ) -> Self

Create a new liquidation watcher.

pub fn with_risk_account_builder(self, builder: Arc<RiskAccountBuilder>) -> Self

Set the risk account builder for portfolio margin accounts.

pub fn with_standard_account_builder( self, builder: Arc<StandardAccountBuilder>, ) -> Self

Set the standard account builder.

pub fn with_quote_provider(self, provider: Arc<dyn QuoteProvider>) -> Self

Set the quote provider used for liquidation repricing.

pub fn with_greeks_cache(self, cache: Arc<GreeksCache>) -> Self

Set the greeks cache for theoretical price fallback.

pub fn with_order_snapshot( self, snapshot: Arc<dyn OrderSnapshotProvider>, ) -> Self

Set the order snapshot provider used for liquidation cancels.

pub fn with_order_sender(self, sender: Sender<UnifiedEngineRequest>) -> Self

Set the order sender used for backend-generated liquidation orders.

pub fn with_event_sender(self, sender: UnboundedSender<EngineMessage>) -> Self

Set the event sender for publishing state changes.

pub fn with_executor(self, executor: Arc<LiquidationExecutor>) -> Self

Set the liquidation executor for onchain calls.

pub async fn run(&self)

Run the watcher loop.

pub async fn run_with_shutdown(&self, shutdown_rx: Receiver<()>)

async fn check_all_accounts(&self) -> Result<()>

Check all accounts for liquidation health.

async fn margin_mode_for_wallet( &self, wallet: &WalletAddress, ) -> Result<MarginMode>

async fn check_portfolio_margin_health( &self, wallet: &WalletAddress, ) -> Result<LiquidationHealthResult>

Check health for a portfolio margin account.

async fn check_standard_margin_health( &self, wallet: &WalletAddress, ) -> Result<LiquidationHealthResult>

Check health for a standard margin account.

async fn process_health_check( &self, wallet: &WalletAddress, health: &LiquidationHealthResult, margin_mode: MarginMode, now: u64, )

Process health check result and trigger state transitions.

async fn handle_pre_liquidation_state( &self, wallet: &WalletAddress, margin_mode: MarginMode, now: u64, )

async fn run_partial_liquidation_cycle( &self, wallet: &WalletAddress, margin_mode: MarginMode, status: &AccountLiquidationStatus, metadata: PartialLiquidationMetadata, now: u64, ) -> Result<PartialCycleOutcome>

async fn persist_pre_liquidation_metadata( &self, wallet: &WalletAddress, metadata: PartialLiquidationMetadata, now: u64, )

async fn sync_and_cancel_orders( &self, wallet: &WalletAddress, tracked_liquidation_client_ids: &[String], cancel_tracked_liquidation_orders: bool, ) -> Result<OpenOrderSyncResult>

async fn build_standard_partial_orders( &self, wallet: &WalletAddress, bonus_bps: u32, ) -> Result<Vec<PartialLiquidationOrderPlan>>

async fn build_portfolio_partial_orders( &self, wallet: &WalletAddress, bonus_bps: u32, ) -> Result<Vec<PartialLiquidationOrderPlan>>

fn standard_partial_candidates( &self, account: &StandardAccount, expected_prices: &HashMap<String, Decimal>, ) -> Vec<LiquidationSliceCandidate>

fn pm_partial_candidates( &self, builder: &RiskAccountBuilder, snapshot: &PortfolioMarginSnapshot, expected_prices: &HashMap<String, Decimal>, ) -> Result<Vec<LiquidationSliceCandidate>>

fn compute_pm_margin( &self, builder: &RiskAccountBuilder, snapshot: &PortfolioMarginSnapshot, ) -> Result<MarginDetails>

fn apply_standard_close( &self, account: &mut StandardAccount, symbol: &str, close_size: Decimal, execution_price: Decimal, ) -> Result<()>

fn apply_pm_option_close( &self, snapshot: &mut PortfolioMarginSnapshot, symbol: &str, close_size: Decimal, execution_price: Decimal, ) -> Result<()>

async fn partial_execution_prices( &self, wallet: &WalletAddress, bonus_bps: u32, ) -> Result<HashMap<String, Decimal>>

fn quote_reference_price(&self, symbol: &str) -> Option<Decimal>

async fn current_positions( &self, wallet: &WalletAddress, ) -> HashMap<String, PositionData>

async fn try_current_position_sizes( &self, wallet: &WalletAddress, ) -> Option<HashMap<String, Decimal>>

fn is_order_reduce_only( &self, current_positions: &HashMap<String, Decimal>, order: &RuntimeOrderSummary, ) -> bool

fn reduce_only_open_order_ids( &self, current_positions: &HashMap<String, Decimal>, open_orders: &[RuntimeOrderSummary], ) -> HashSet<u64>

async fn cancel_open_order( &self, wallet: &WalletAddress, target: &CancelTarget, ) -> Result<()>

async fn submit_partial_liquidation_order( &self, wallet: &WalletAddress, plan: &PartialLiquidationOrderPlan, now: u64, order_index: usize, ) -> Result<(String, String, OrderUpdateMessage)>

async fn send_engine_order( &self, message: OrderActionMessage, ) -> Result<OrderUpdateMessage>

fn emit_state_change( &self, previous: &LiquidationState, status: &AccountLiquidationStatus, timestamp: u64, )

Emit a state change event.

impl LiquidationWatcher

async fn has_short_option_positions( &self, wallet: &WalletAddress, ) -> Option<bool>

Trait Implementations

impl Service for LiquidationWatcher

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,