Struct UnifiedEngineBuilder 

pub struct UnifiedEngineBuilder {

    config: Config,
    order_buffer_size: usize,
    database_path: Option<String>,
    db_auth: Option<DbAuthConfig>,
    allow_no_database: bool,
    skip_db_migrations: bool,
    mmp_cache: Option<Arc<MmpCache>>,
    tier_cache: Option<Arc<TierCache>>,
    portfolio_service: Option<Arc<dyn PortfolioService + Send + Sync>>,
    portfolio_cache: Option<Arc<PortfolioCache>>,
    greeks_cache: Option<Arc<GreeksCache>>,
    mark_price_oracles: HashMap<String, Arc<HyperliquidMarkPriceOracle>>,
    risk_account_builder: Option<Arc<RiskAccountBuilder>>,
    standard_account_builder: Option<Arc<StandardAccountBuilder>>,
    liquidation_cache: Option<Arc<LiquidationCache>>,
    risk_vol_oracle: Option<SharedVolOracle>,
    test_funded_accounts: Vec<(WalletAddress, f64)>,
    ws_event_sender: Option<UnboundedSender<EngineMessage>>,
    journal_writer: Option<SharedEngineJournalWriter>,
    journal_batch_sender: Option<JournalBatchSender>,
    nats_publisher: Option<NatsPublisher>,
    nats_balance_update_publisher: Option<NatsBalanceUpdatePublisher>,
    read_snapshot: Option<Arc<ArcSwap<EngineSnapshot>>>,
    runtime_settings: Option<EngineRuntimeSettings>,
    startup_balance_ledger: Option<BalanceLedger>,
}

Builder for creating the unified engine

Fields

config: Config

order_buffer_size: usize

database_path: Option<String>

db_auth: Option<DbAuthConfig>

allow_no_database: bool

skip_db_migrations: bool

mmp_cache: Option<Arc<MmpCache>>

tier_cache: Option<Arc<TierCache>>

portfolio_service: Option<Arc<dyn PortfolioService + Send + Sync>>

portfolio_cache: Option<Arc<PortfolioCache>>

greeks_cache: Option<Arc<GreeksCache>>

mark_price_oracles: HashMap<String, Arc<HyperliquidMarkPriceOracle>>

risk_account_builder: Option<Arc<RiskAccountBuilder>>

standard_account_builder: Option<Arc<StandardAccountBuilder>>

liquidation_cache: Option<Arc<LiquidationCache>>

risk_vol_oracle: Option<SharedVolOracle>

test_funded_accounts: Vec<(WalletAddress, f64)>

ws_event_sender: Option<UnboundedSender<EngineMessage>>

journal_writer: Option<SharedEngineJournalWriter>

journal_batch_sender: Option<JournalBatchSender>

nats_publisher: Option<NatsPublisher>

nats_balance_update_publisher: Option<NatsBalanceUpdatePublisher>

read_snapshot: Option<Arc<ArcSwap<EngineSnapshot>>>

runtime_settings: Option<EngineRuntimeSettings>

startup_balance_ledger: Option<BalanceLedger>

Implementations

impl UnifiedEngineBuilder

pub fn new(config: Config) -> Self

pub fn with_runtime_settings(self, settings: EngineRuntimeSettings) -> Self

pub fn with_startup_balance_ledger(self, balance_ledger: BalanceLedger) -> Self

Seed the engine-owned balance ledger at startup.

Runtime readers consume balances through EngineSnapshot publication, not through this builder input after construction.

pub fn with_read_snapshot(self, snapshot: Arc<ArcSwap<EngineSnapshot>>) -> Self

Set the ArcSwap snapshot handle for lock-free API reads. If not set, the engine creates its own (tests).

pub fn with_journal_writer(self, writer: SharedEngineJournalWriter) -> Self

Set the durable engine journal writer for restart-safe ACK.

pub fn with_journal_batch_sender(self, sender: JournalBatchSender) -> Self

Set the batched journal sender for async PostgreSQL writes.

pub fn with_nats_publisher(self, publisher: NatsPublisher) -> Self

pub fn with_nats_balance_update_publisher( self, publisher: NatsBalanceUpdatePublisher, ) -> Self

pub fn with_order_buffer_size(self, size: usize) -> Self

pub fn with_vol_oracle(self, oracle: SharedVolOracle) -> Self

pub fn with_risk_vol_oracle(self, oracle: SharedVolOracle) -> Self

pub fn with_database(self, path: &str) -> Self

pub fn with_db_auth(self, auth: DbAuthConfig) -> Self

pub fn without_database(self) -> Self

pub fn with_skip_db_migrations(self) -> Self

Connect to the database but skip DDL (migrations).

Used in standby mode: the engine can read max IDs from a readonly replica but cannot run migrations. On promote, a read-write DieselEventHandler is swapped in via set_diesel_handler.

pub fn allow_no_database_for_tests(self) -> Self

Allow running without database (for tests only - DO NOT USE IN PRODUCTION)

pub fn with_mock_journal(self) -> Self

Use an in-memory journal for testing. Provides real idempotency checks and event capture without requiring a database. This is the preferred way to test journaling logic.

pub fn with_mmp_cache(self, cache: Arc<MmpCache>) -> Self

Set the MmpCache for market maker protection

pub fn with_tier_cache(self, cache: Arc<TierCache>) -> Self

Set the TierCache for position limit checks

pub fn with_portfolio_service( self, service: Arc<dyn PortfolioService + Send + Sync>, ) -> Self

Set the PortfolioService for executed state (positions + cash).

This is the canonical source of truth. Margin checks will read executed positions from this service instead of the stale self.accounts map.

pub fn with_portfolio_cache(self, cache: Arc<PortfolioCache>) -> Self

Set the portfolio cache for synchronous fill processing in the engine hot path.

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

Set the GreeksCache for spot price lookups in margin calculations. This replaces the legacy reference_prices mechanism for live trading.

pub fn with_mark_price_oracles( self, oracles: HashMap<String, Arc<HyperliquidMarkPriceOracle>>, ) -> Self

Set the mark price oracles for spot/forward price lookups.

Maps underlying symbol (e.g., “BTC”, “ETH”) to oracle instance. This is the canonical source for spot prices in margin calculations.

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

Set the RiskAccountBuilder for building risk accounts.

This is the single source of truth for “how to build an Account for PM”. Required for margin calculations to work correctly.

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

Set the StandardAccountBuilder for building StandardAccounts.

Used for Standard margin mode accounts (Deribit-style linear margin). If not set, Standard mode margin checks will use a fallback.

pub fn with_liquidation_cache(self, cache: Arc<LiquidationCache>) -> Self

Set the LiquidationCache for pre-liquidation order blocking.

When set, orders from accounts in pre-liquidation state will be checked to ensure they don’t increase risk. Risk-reducing orders are still allowed.

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

Set the direct WS event sender (low-latency WS delivery).

pub fn with_funded_test_accounts( self, accounts: Vec<(WalletAddress, f64)>, ) -> Self

Pre-fund test accounts (for integration tests only - DO NOT USE IN PRODUCTION) Adds multiple accounts with the specified cash balance

pub fn build( self, event_sender: UnboundedSender<EngineMessage>, shutdown_sender: Sender<()>, ) -> (UnifiedEngine, Sender<UnifiedEngineRequest>, Sender<MarketRequest>)

Build the engine.

The event_sender is used for direct event publishing (OrderUpdate, TradeMessage, etc.). L2Update events are published via the journal → outbox path.

The event_sender is ALWAYS used because:

• OrderUpdate events (cancels, fills) must be delivered directly to users via WebSocket
• Expiry-triggered cancels happen outside the journaled order path
• The outbox only handles L2Update events (public market data)

pub fn build_with_info( self, event_sender: UnboundedSender<EngineMessage>, shutdown_sender: Sender<()>, ) -> UnifiedEngineBuilderResult

Build the engine with additional startup info.

fn apply_common_config(&self, engine: &mut UnifiedEngine)