Struct CatalogManager 

pub struct CatalogManager {
    diesel_db: Arc<DieselDb>,
    config: CatalogConfig,
    market_sender: Sender<MarketRequest>,
    mark_price_oracles: HashMap<String, Arc<HyperliquidMarkPriceOracle>>,
    interval_secs: u64,
    trading_mode_notify: Option<Sender<TradingModeUpdate>>,
}

CatalogManager handles continuous market/instrument reconciliation

Fields

diesel_db: Arc<DieselDb>

Async Diesel database connection pool

config: CatalogConfig

Catalog configuration

market_sender: Sender<MarketRequest>

Channel to send market creation requests (uses MarketRequest with response channel)

mark_price_oracles: HashMap<String, Arc<HyperliquidMarkPriceOracle>>

Mark price oracles for spot prices

interval_secs: u64

Reconciliation interval

trading_mode_notify: Option<Sender<TradingModeUpdate>>

Live notify channel to the engine main loop. Every time sync_trading_modes_to_db rewrites any row we publish the full current underlying -> TradingModes map here. watch semantics mean the engine only observes the latest value, which is what we want – we never care about superseded updates.

Implementations

impl CatalogManager

pub fn new( diesel_db: Arc<DieselDb>, config: CatalogConfig, market_sender: Sender<MarketRequest>, mark_price_oracles: HashMap<String, Arc<HyperliquidMarkPriceOracle>>, interval_secs: u64, ) -> Self

Create a new CatalogManager

pub fn with_trading_mode_notify(self, sender: Sender<TradingModeUpdate>) -> Self

Attach a tokio::sync::watch::Sender that this catalog manager will publish underlying → trading_mode updates on whenever a periodic sync rewrites any row. Optional — call sites that don’t need live notifications can omit this and the catalog manager behaves exactly as before (warn-only drift).

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

Execute one reconciliation tick

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

Perform the actual reconciliation work

async fn process_expiry( &self, underlying: &str, expiry_info: &ExpiryInfo, spot_price: f64, ) -> Result<()>

Process a single expiry for an underlying

async fn get_spot_price(&self, underlying: &str) -> Option<f64>

Get spot price from oracle

async fn create_market( &self, underlying: &str, expiry: i64, strike: f64, is_call: bool, ) -> Result<()>

Create a market/instrument via engine channel

Trait Implementations

impl Service for CatalogManager

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,