Struct DatabaseHandler 

pub struct DatabaseHandler {
    pool: Arc<DbPool>,
}

Synchronous persistence handler. Owns an r2d2 connection pool and implements all engine-path traits from hypercall_db (orders, instruments, tiers, settlements, journal replay, archiver, RFQ).

Constructors run Diesel migrations and ensure_enum_values by default. Use Self::new_readonly or Self::with_pool_no_migrations to skip.

Fields

pool: Arc<DbPool>

Implementations

impl DatabaseHandler

pub fn new(database_url: &str) -> Result<Self>

Create a new handler: build pool + run migrations.

pub fn new_with_pool_size(database_url: &str, pool_max: u32) -> Result<Self>

Create a new handler with explicit pool size: build pool + run migrations.

pub fn new_with_auth(auth: DbAuthConfig, pool_max: u32) -> Result<Self>

Create a new handler with DbAuthConfig: build pool + run migrations.

pub fn new_with_timeouts( database_url: &str, pool_max: u32, statement_timeout_ms: u32, lock_timeout_ms: u32, ) -> Result<Self>

Create a handler with custom statement/lock timeouts, no migrations. Used by db-archiver which needs longer timeouts for batch operations.

pub fn new_with_timeouts_auth( auth: DbAuthConfig, pool_max: u32, statement_timeout_ms: u32, lock_timeout_ms: u32, ) -> Result<Self>

Create a handler with custom timeouts and DbAuthConfig, no migrations.

pub fn new_readonly(database_url: &str, pool_max: u32) -> Result<Self>

Create a handler with pool only, no migrations (for read-only replicas).

pub fn new_readonly_auth(auth: DbAuthConfig, pool_max: u32) -> Result<Self>

Create a readonly handler with DbAuthConfig, no migrations.

pub fn with_pool(pool: Arc<DbPool>) -> Result<Self>

Wrap an existing pool + run migrations.

pub fn with_pool_no_migrations(pool: Arc<DbPool>) -> Self

Wrap an existing pool, skip migrations.

pub fn pool(&self) -> Arc<DbPool>

Expose the pool (Arc-cloned).

pub fn get_pool(&self) -> DbPool

Clone the inner pool (not the Arc).

pub fn run_migrations(&self) -> Result<()>

Run pending Diesel migrations + ensure enum values.

fn ensure_real_liquidation_schema(conn: &mut PgConnection) -> Result<()>

fn build_pool( auth: &DbAuthConfig, pool_max: u32, statement_timeout_ms: u32, lock_timeout_ms: u32, ) -> Result<Self>

fn ensure_enum_values(conn: &mut PgConnection) -> Result<()>

Ensure all required Postgres enum values exist.

fn ensure_directive_action_key_enum(conn: &mut PgConnection) -> Result<()>

Ensure the directive outbox action-key enum exists even if an older duplicate-version migration was recorded before this enum migration ran.

fn ensure_directive_outbox_wallet_address(conn: &mut PgConnection) -> Result<()>

pub(crate) fn order_update_status_to_db( status: OrderUpdateStatus, ) -> &'static str

Map an OrderUpdateStatus enum to its DB string representation.

pub(crate) fn observe_diesel_option_token_violation(err: &Error)

Log and count option_token_address unique constraint violations.

pub fn update_snapshot_boundary_sync(&self, last_command_id: i64) -> Result<()>

Persist the engine state snapshot’s last_command_id to Postgres so the db-archiver can compute a safe deletion boundary. Must be called after every successful snapshot write to disk.

pub fn directive_outbox_exists_sync(&self, directive_id: &str) -> Result<bool>

Check whether a directive outbox row exists for the given directive_id.

pub async fn get_max_rsm_deposit_credit_observed_block( &self, ) -> Result<Option<u64>>

Get the maximum observed block from rsm_deposit_credits.

pub async fn ensure_observed_deposit_account( &self, account: &WalletAddress, ) -> Result<()>

Ensure a user_tiers row exists for the wallet that will receive deposit credit.

pub async fn claim_rsm_deposit_credit( &self, input: &RsmDepositCreditClaimInput, ) -> Result<RsmDepositCreditClaimRecord>

Claim an RSM deposit credit (idempotent upsert).

pub async fn mark_rsm_deposit_credit_submitted( &self, request_id: &str, ) -> Result<()>

Mark an RSM deposit credit as submitted.

pub async fn mark_rsm_deposit_credit_failed( &self, request_id: &str, error: &str, ) -> Result<()>

Mark an RSM deposit credit as failed.

pub async fn pending_rsm_usdc_deposit_for_amount( &self, amount_wei: &str, ) -> Result<Option<RsmUsdcDepositMatch>>

Return the oldest pending Exchange.UsdcDeposit event for a HyperCore cash amount.

pub async fn pending_rsm_usdc_deposit_for_evm_tx_hash( &self, evm_tx_hash: &str, amount_wei: &str, ) -> Result<Option<RsmUsdcDepositMatch>>

Return the pending Exchange.UsdcDeposit event for a CoreWriter writer-action EVM tx hash.

pub async fn pm_liquidity_deposit_for_evm_tx_hash( &self, evm_tx_hash: &str, amount_wei: &str, ) -> Result<Option<RsmUsdcDepositMatch>>

Return a PM liquidity Exchange deposit by CoreWriter writer-action EVM tx hash.

pub async fn pm_liquidity_deposit_for_amount( &self, amount_wei: &str, ) -> Result<Option<RsmUsdcDepositMatch>>

Return the oldest PM liquidity Exchange deposit for a HyperCore cash amount.

pub async fn mark_pm_liquidity_deposit_hypercore_matched( &self, request_id: &str, event_hash: &str, ) -> Result<()>

Mark a PM liquidity Exchange deposit as consumed by a HyperCore cash event.

pub async fn pending_rsm_usdc_deposit_for_credited_hypercore_event( &self, event_hash: &str, amount_wei: &str, ) -> Result<Option<RsmUsdcDepositMatch>>

Return a pending Exchange.UsdcDeposit request for an already credited HyperCore event.

pub async fn credited_wallet_for_hypercore_cash_event( &self, event_hash: &str, ) -> Result<Option<WalletAddress>>

Return the credited wallet for an already-applied HyperCore cash event.

pub async fn non_crediting_hypercore_cash_event( &self, event_hash: &str, amount_usdc: Decimal, ) -> Result<bool>

Return true when this HyperCore cash event is already recorded as non-crediting.

pub async fn list_recent_cash_deposit_monitoring_rows( &self, limit: i64, offset: i64, ) -> Result<Vec<DepositMonitoringRow>>

Return recent cash deposit attribution rows for the admin panel.

pub async fn apply_hypercore_cash_deposit( &self, input: &HypercoreCashLedgerApply, ) -> Result<HypercoreCashLedgerApplyResult>

Apply a HyperCore cash deposit (idempotent).

pub async fn record_hypercore_cash_deposit_non_crediting( &self, input: &HypercoreCashLedgerApply, ) -> Result<()>

Record an observed Exchange HyperCore deposit that must not credit engine cash.

pub async fn record_hypercore_cash_deposit_pending_margin_mode( &self, input: &HypercoreCashLedgerApply, ) -> Result<()>

Record a HyperCore cash deposit that cannot yet be credited because margin mode is unknown. The row pins the replay watermark until a later replay can apply the credit with a durable ledger sequence.

pub fn get_exchange_cash_ledger_watermark_sync(&self) -> Result<Option<i64>>

Get the exchange-wide cash ledger watermark (max event_time_ms).

pub async fn get_rsm_signer_nonce( &self, signer: &WalletAddress, ) -> Result<Option<RsmSignerNonceRecord>>

Load the current nonce state for a signer address (sync, used by startup code).

pub async fn get_option_instrument_for_credit( &self, token: &WalletAddress, ) -> Result<Option<OptionInstrumentForCredit>>

Look up an option instrument by its on-chain token address.

impl DatabaseHandler

pub(crate) fn upsert_order_info( conn: &mut PgConnection, info: &NewOrderInfo, ) -> Result<()>

Upsert static order info into order_infos. Used by handle_event_with_conn and the OrderWriter trait impl.

pub(crate) fn insert_order_action( conn: &mut PgConnection, action: &NewOrderAction, ) -> Result<()>

Insert an order action audit trail entry. Used by handle_event_with_conn and the OrderWriter trait impl.

pub fn handle_event_sync(&self, event: &EngineMessage) -> Result<()>

Persist a single engine event, acquiring a connection from the pool.

pub fn handle_event_batch_sync(&self, events: &[EngineMessage]) -> Result<()>

Persist a batch of engine events in a single transaction.

pub fn handle_event_with_conn( &self, conn: &mut PgConnection, event: &EngineMessage, ) -> Result<()>

Persist a single engine event using the provided connection.

pub fn batch_cancel_expired_orders_sync( &self, cancels: &[ExpiredOrderCancel], reason: &str, ) -> Result<usize>

Batch-insert CANCELED rows into order_updates for orders on expired instruments. Skips orders that already have a terminal status (CANCELED, FILLED, REJECTED) in order_infos for idempotency.

Runs as a single serializable transaction with retry.

fn save_liquidation_state_with_conn( &self, conn: &mut PgConnection, state: &NewLiquidationState, ) -> Result<()>

fn insert_liquidation_history_with_conn( &self, conn: &mut PgConnection, entry: &NewLiquidationHistory, ) -> Result<i64>

fn upsert_liquidation_auction_with_conn( &self, conn: &mut PgConnection, auction: &NewLiquidationAuction, ) -> Result<()>

fn update_liquidation_auction_with_conn( &self, conn: &mut PgConnection, auction_id: &str, update: &UpdateLiquidationAuction, ) -> Result<()>

fn get_liquidation_auction_with_conn( &self, conn: &mut PgConnection, auction_id: &str, ) -> Result<Option<LiquidationAuctionRecord>>

fn persist_transaction_update( conn: &mut PgConnection, tx_update: &TransactionUpdate, ) -> Result<()>

Update directive outbox status from a transaction lifecycle event. Withdrawal failures are not auto-refunded here. Until withdrawal proofs are user-driven, terminal withdrawal states require manual reconciliation.

impl DatabaseHandler

pub(crate) fn apply_fill_ledger_side_effects( conn: &mut PgConnection, wallet: &WalletAddress, fill: &Fill, realized_delta: Decimal, premium_delta: Decimal, ) -> Result<()>

Trait Implementations

impl ArchiverReader for DatabaseHandler

fn find_safe_boundary(&self, min_age_hours: i64) -> Result<ArchivalBoundary>

Find the safe archival boundary based on the engine snapshot’s last_command_id and the configured minimum age.

fn fetch_events_batch( &self, max_command_id: i64, age_cutoff: &DateTime<Utc>, batch_size: i64, after_event_id: Option<i64>, ) -> Result<Vec<ArchivedEvent>>

Fetch a batch of engine events eligible for archival.

fn fetch_orphan_commands_batch( &self, max_command_id: i64, age_cutoff: &DateTime<Utc>, batch_size: i64, after_command_id: Option<i64>, ) -> Result<Vec<ArchivedCommand>>

Fetch engine commands that have no remaining engine events (orphans).

fn fetch_order_actions_batch( &self, age_cutoff: &DateTime<Utc>, batch_size: i64, after_id: Option<i32>, ) -> Result<Vec<ArchivedOrderAction>>

Fetch a batch of order actions eligible for archival.

fn fetch_order_updates_batch( &self, age_cutoff: &DateTime<Utc>, batch_size: i64, after_id: Option<i32>, ) -> Result<Vec<ArchivedOrderUpdate>>

Fetch a batch of order updates eligible for archival.

impl ArchiverWriter for DatabaseHandler

fn delete_events(&self, event_ids: &[i64]) -> Result<usize>

Delete engine events by their IDs.

fn delete_commands(&self, command_ids: &[i64]) -> Result<usize>

Delete engine commands (and their digests) by their IDs.

fn delete_order_actions(&self, ids: &[i32]) -> Result<usize>

Delete order actions by their IDs.

fn delete_order_updates(&self, ids: &[i32]) -> Result<usize>

Delete order updates by their IDs.

fn delete_notifications_before( &self, cutoff: &DateTime<Utc>, batch_size: i64, ) -> Result<usize>

Delete a batch of notifications older than cutoff.

fn delete_notifications_over_per_user_cap( &self, max_per_user: i64, batch_size: i64, ) -> Result<usize>

Delete notifications that exceed the per-user cap.

impl DirectiveOutboxReader for DatabaseHandler

fn claim_next_directive_outbox_item_sync( &self, ) -> Result<Option<DirectiveOutboxRow>>

fn get_directive_status_sync( &self, directive_id: &str, ) -> Result<Option<DirectiveStatusRow>>

Look up the delivery status of a single directive by its ID.

fn get_withdrawal_history_sync( &self, wallet: &WalletAddress, limit: i64, ) -> Result<Vec<DirectiveStatusRow>>

Return withdrawal directive history for a wallet, most recent first.

fn list_directive_outbox_delivery_metrics_sync( &self, ) -> Result<Vec<DirectiveOutboxDeliveryMetricsRow>>

Return retryable directive delivery backlog grouped by stable low-cardinality labels.

fn list_recent_directive_outbox_rows_sync( &self, limit: i64, offset: i64, ) -> Result<Vec<DirectiveOutboxRecentRow>>

Return recent directive outbox rows for operator debugging.

impl DirectiveOutboxWriter for DatabaseHandler

fn mark_directive_outbox_delivery_failed_sync( &self, outbox_seq: i64, error: &str, ) -> Result<()>

fn mark_directive_outbox_dead_lettered_sync( &self, outbox_seq: i64, error: &str, ) -> Result<()>

fn mark_directive_outbox_manual_reconciliation_sync( &self, outbox_seq: i64, error: &str, ) -> Result<()>

Stop retrying a directive whose on-chain outcome is unknown.

fn record_directive_submitter_submission_sync( &self, request_id: &str, submitter_address: &Address, submitter_nonce: u64, ) -> Result<()>

Store the submitter-owned submission pointer for a directive.

fn persist_directive_transaction_update_sync( &self, request_id: &str, status: TransactionStatus, tx_hash: Option<&str>, error: Option<&str>, ) -> Result<()>

Persist transaction-submitter status updates for a directive.

impl EngineJournalBatchWriter for DatabaseHandler

fn insert_engine_journal_batch_sync( &self, entries: &[EngineJournalEntryInsert], persist_digests: bool, rsm_blocks: Option<&EngineJournalRsmBlockBatch>, ) -> Result<EngineJournalBatchInsertResult>

fn lookup_engine_journal_command_ids_sync( &self, request_ids: &[Uuid], ) -> Result<Vec<(Uuid, i64)>>

impl InstrumentReader for DatabaseHandler

fn get_all_instruments_sync(&self) -> Result<Vec<InstrumentRecord>>

Load all instruments regardless of status.

fn get_instruments_by_status_sync( &self, status: &str, ) -> Result<Vec<InstrumentRecord>>

Load instruments filtered by status (e.g. “ACTIVE”, “PENDING_SETTLEMENT”).

fn get_instrument_status_counts_sync(&self) -> Result<Vec<(String, i64)>>

Count instruments grouped by status.

fn get_markets_expiring_within_sync(&self, seconds: i64) -> Result<i64>

Count markets (underlying+expiry) expiring within seconds from now.

fn get_active_instruments_expired_by_sync( &self, now_ts_secs: u64, ) -> Result<Vec<InstrumentRecord>, Error>

Load active instruments whose expiry timestamp is at or before now_ts_secs.

impl InstrumentWriter for DatabaseHandler

fn save_market_and_instrument_sync( &self, underlying: &str, expiry: i64, instrument: &InstrumentRecord, ) -> Result<()>

Persist a new instrument and its parent market. Only used for new ACTIVE instruments – status transitions on existing instruments go through update_instrument_status_sync.

fn delete_market_and_instrument_sync(&self, symbol: &str) -> Result<()>

Delete an instrument and its parent market row.

fn update_instrument_status_sync( &self, symbols: &[String], status: &str, ) -> Result<usize>

Batch-update instrument status. Returns number of rows updated.

fn transition_active_instruments_to_expired_pending_sync( &self, symbols: &[String], ) -> Result<usize>

Transition only instruments that are still ACTIVE to EXPIRED_PENDING_PRICE. Returns number of rows updated.

impl InstrumentsSnapshotReader for DatabaseHandler

fn get_latest_instruments_snapshot_id_sync(&self) -> Result<Option<i64>>

Load the latest instruments snapshot ID.

fn load_instruments_snapshot_sync( &self, snapshot_id: i64, ) -> Result<InstrumentsSnapshotData>

Load instruments snapshot data for a given snapshot ID.

impl InstrumentsSnapshotWriter for DatabaseHandler

fn write_instruments_snapshot_sync( &self, input: &InstrumentsSnapshotInput, ) -> Result<i64>

Write a complete instruments snapshot in a single transaction. Returns the new snapshot ID.

impl JournalReplayReader for DatabaseHandler

fn get_next_engine_command_id_sync(&self) -> Result<i64>

Next command_id for sequence initialization (MAX + 1, or 1 if empty).

fn get_journal_command_id_bounds_sync( &self, ) -> Result<Option<JournalCommandIdBounds>>

Inclusive command-id bounds for replayable rows in engine_commands.

fn count_non_replayable_commands_in_range_sync( &self, start_command_id: i64, end_command_id: i64, ) -> Result<i64>

Count durable non-replayable journal rows in a command-id range (exclusive start, inclusive end).

fn get_commands_with_l2_after_seq_sync( &self, l2_seq: i64, ) -> Result<Vec<ReplayCommand>>

Fetch commands that produced L2 events after the snapshot’s L2 sequence. Used for the primary replay path (Pass 1).

fn get_replay_commands_after_command_id_sync( &self, after_command_id: i64, up_to_command_id: Option<i64>, limit: i64, ) -> Result<Vec<ReplayCommand>>

Paginated replay cursor: fetch up to limit commands after after_command_id, optionally bounded by up_to_command_id.

fn get_fill_events_for_command_range_sync( &self, start_command_id: i64, end_command_id: i64, ) -> Result<Vec<Vec<u8>>>

Raw OrderFilled event payloads in a command_id range (exclusive start, inclusive end).

fn get_portfolio_events_for_command_range_sync( &self, start_command_id: i64, end_command_id: i64, ) -> Result<Vec<PortfolioReplayEvent>>

Portfolio-relevant events (OrderFilled + PositionExpired) in a command_id range. Used during portfolio cache replay.

fn get_order_update_events_for_command_range_sync( &self, start_command_id: i64, end_command_id: i64, ) -> Result<Vec<Vec<u8>>>

Raw OrderUpdate event payloads in a command_id range (exclusive start, inclusive end).

fn get_max_l2_seq_from_events_sync(&self) -> Result<i64>

Maximum L2 sequence from engine_events. Returns 0 if no L2 events exist.

fn get_fill_events_after_seq_sync(&self, l2_seq: i64) -> Result<Vec<Vec<u8>>>

Raw OrderFilled event payloads after the snapshot boundary (by L2 sequence). Used during replay Pass 2 (fill reconciliation).

fn get_order_update_events_after_seq_sync( &self, l2_seq: i64, ) -> Result<Vec<Vec<u8>>>

Raw OrderUpdate event payloads after the snapshot boundary (by L2 sequence). Used during replay Pass 3 (side-effect cancel detection).

impl MmpConfigReader for DatabaseHandler

fn get_mmp_config_sync( &self, wallet: &WalletAddress, currency: &str, ) -> Result<Option<MmpConfigRecord>>

Load MMP config for a specific wallet+currency pair.

fn get_all_mmp_configs_for_wallet_sync( &self, wallet: &WalletAddress, ) -> Result<Vec<MmpConfigRecord>>

Load all MMP configs for a wallet (all currencies).

fn get_all_mmp_configs_sync(&self) -> Result<Vec<MmpConfigRecord>>

Load all MMP configs across all wallets.

impl MmpConfigWriter for DatabaseHandler

fn save_mmp_config_sync(&self, config: &MmpConfigRecord) -> Result<()>

Upsert an MMP config (insert or update on wallet+currency conflict).

fn delete_mmp_config_sync( &self, wallet: &WalletAddress, currency: &str, ) -> Result<()>

Delete an MMP config for a specific wallet+currency pair.

impl OracleWriter for DatabaseHandler

fn save_oracle_price_samples_sync( &self, samples: &[NewOraclePriceSampleInput], ) -> Result<()>

Persist a batch of price samples for a given symbol/expiry. Duplicate samples (by symbol, expiry, timestamp, source) are silently ignored.

fn save_oracle_settlement_price_sync( &self, settlement: &NewOracleSettlementPriceInput, ) -> Result<()>

Persist a finalized settlement price. If a settlement already exists for this (symbol, expiry), it is silently ignored.

fn get_oracle_settlement_price_sync( &self, symbol: &str, expiry_timestamp: i64, ) -> Result<Option<f64>>

Load a settlement price from the database. Returns None if no settlement exists for this symbol/expiry.

impl OrderReader for DatabaseHandler

fn get_order_infos_sync( &self, wallet: Option<&WalletAddress>, ) -> Result<Vec<OrderInfoRecord>>

Load materialized order infos, optionally filtered by wallet.

fn get_client_ids_by_order_ids_sync( &self, order_ids: &[i64], ) -> Result<HashMap<i64, Option<String>>>

Batch lookup of client_ids by order_ids (sync path).

fn get_terminal_order_ids_sync(&self, order_ids: &[i64]) -> Result<Vec<i64>>

Return which of the given order IDs are in a terminal state.

fn get_max_order_id_sync(&self) -> Result<u64>

MAX(order_id) + 1 for sequence initialization.

fn get_max_trade_id_sync(&self) -> Result<u64>

MAX(trade_id) + 1 for sequence initialization.

impl OrderWriter for DatabaseHandler

fn persist_order_info_sync(&self, info: &PersistOrderInfo) -> Result<()>

Persist static order info (upsert on order_id).

fn persist_order_action_sync(&self, action: &PersistOrderAction) -> Result<()>

Persist an order action audit trail entry.

fn persist_order_update_sync(&self, update: &OrderUpdateMessage) -> Result<()>

Persist an order status update + materialize into order_infos.

fn persist_fill_with_side_effects_sync( &self, fill: &Fill, side_effects: &FillSideEffects, ) -> Result<(bool, bool)>

Persist a fill atomically with trades + ledger side effects.

fn batch_cancel_orders_for_settlement_sync( &self, order_ids: &[i64], timestamp_ms: i64, ) -> Result<usize>

Batch cancel orders for settlement.

fn cancel_orphaned_orders_by_symbols_sync( &self, symbols: &[String], ) -> Result<usize>

Cancel orphaned orders by symbol.

impl PmSettlementProjectionSyncReader for DatabaseHandler

fn list_pm_settlement_pools_sync( &self, ) -> Result<Vec<PmSettlementPoolProjection>>

fn list_pm_settlement_accounts_sync( &self, ) -> Result<Vec<PmSettlementAccountProjection>>

fn list_pm_settlement_events_sync( &self, ) -> Result<Vec<PmSettlementEventProjection>>

fn list_pm_settlement_interest_events_sync( &self, ) -> Result<Vec<PmSettlementInterestEventProjection>>

fn list_pm_settlement_repayment_events_sync( &self, ) -> Result<Vec<PmSettlementRepaymentEventProjection>>

fn list_pm_recovery_plans_sync(&self) -> Result<Vec<PmRecoveryPlanProjection>>

fn list_pm_recovery_actions_sync( &self, ) -> Result<Vec<PmRecoveryActionProjection>>

impl PmSettlementProjectionSyncWriter for DatabaseHandler

fn apply_pm_settlement_projection_writes_sync( &self, writes: &[PmSettlementProjectionWrite], ) -> Result<()>

impl PortfolioSnapshotReader for DatabaseHandler

fn get_latest_portfolio_snapshot_id_sync(&self) -> Result<Option<i64>>

Load the latest portfolio snapshot ID.

fn portfolio_snapshot_exists_sync(&self, snapshot_id: i64) -> Result<bool>

Check if a portfolio snapshot exists.

fn load_portfolio_snapshot_sync( &self, snapshot_id: i64, ) -> Result<PortfolioSnapshotData>

Load portfolio snapshot data for a given snapshot ID.

impl PortfolioSnapshotWriter for DatabaseHandler

fn write_portfolio_snapshot_sync( &self, input: &PortfolioSnapshotInput, ) -> Result<i64>

Write a complete portfolio snapshot in a single transaction. Returns the new snapshot ID.

impl RfqReader for DatabaseHandler

fn get_all_quote_providers_sync(&self) -> Result<Vec<QuoteProviderRecord>>

Load all registered quote providers.

impl RfqWriter for DatabaseHandler

fn upsert_quote_provider_sync(&self, qp: &QuoteProviderRecord) -> Result<()>

Upsert a quote provider registration.

fn update_quote_provider_status_sync( &self, wallet: &WalletAddress, status: &str, ) -> Result<()>

Update a quote provider’s status (“active” / “suspended”).

fn persist_rfq_record_sync( &self, rfq_id: &Uuid, taker_wallet: &WalletAddress, underlying: &str, status: &str, taker_signature: &str, taker_nonce: u64, legs_hash: &[u8; 32], legs: &[(String, String, Decimal)], expires_at_ms: u64, ) -> Result<()>

Persist an RFQ record and its legs atomically.

fn persist_rfq_quote_sync( &self, quote_id: &Uuid, rfq_id: &Uuid, qp_wallet: &WalletAddress, net_premium: Decimal, valid_for_ms: u64, qp_signature: &str, qp_nonce: u64, legs: &[(String, String, Decimal, Decimal)], expires_at_ms: u64, ) -> Result<()>

Persist a quote provider’s firm quote and its legs atomically.

fn update_rfq_status_sync(&self, rfq_id: &Uuid, status: &str) -> Result<()>

Update RFQ record status.

impl RsmCreditReader for DatabaseHandler

fn directive_outbox_exists_sync(&self, directive_id: &str) -> Result<bool>

Check whether a directive outbox row exists for the given directive_id.

fn get_max_rsm_deposit_credit_observed_block<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<u64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Return the replay watermark for RSM deposit credits.

fn get_exchange_cash_ledger_watermark_sync(&self) -> Result<Option<i64>>

Return the replay watermark for exchange cash ledger events.

fn get_option_instrument_for_credit<'life0, 'life1, 'async_trait>( &'life0 self, token: &'life1 WalletAddress, ) -> Pin<Box<dyn Future<Output = Result<Option<OptionInstrumentForCredit>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Look up an option instrument by its on-chain token address.

fn list_recent_cash_deposit_monitoring_rows<'life0, 'async_trait>( &'life0 self, limit: i64, offset: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<DepositMonitoringRow>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Return recent cash deposit attribution rows for admin monitoring.

impl RsmCreditWriter for DatabaseHandler

fn ensure_observed_deposit_account<'life0, 'life1, 'async_trait>( &'life0 self, account: &'life1 WalletAddress, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Ensure an observed deposit account has a tier row before crediting.

fn claim_rsm_deposit_credit<'life0, 'life1, 'async_trait>( &'life0 self, input: &'life1 RsmDepositCreditClaimInput, ) -> Pin<Box<dyn Future<Output = Result<RsmDepositCreditClaimRecord>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Claim an observed RSM deposit credit idempotently.

fn mark_rsm_deposit_credit_submitted<'life0, 'life1, 'async_trait>( &'life0 self, request_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark an RSM deposit credit as submitted to the engine/journal path.

fn mark_rsm_deposit_credit_failed<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, request_id: &'life1 str, error: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Mark an RSM deposit credit as failed so observers can quarantine invalid public events.

fn pending_rsm_usdc_deposit_for_amount<'life0, 'life1, 'async_trait>( &'life0 self, amount_wei: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<RsmUsdcDepositMatch>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Match a pending Exchange.UsdcDeposit event to one observed HyperCore cash deposit.

fn pending_rsm_usdc_deposit_for_evm_tx_hash<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, evm_tx_hash: &'life1 str, amount_wei: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<RsmUsdcDepositMatch>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Match a pending Exchange.UsdcDeposit event to a CoreWriter writer-action EVM tx hash.

fn pending_rsm_usdc_deposit_for_credited_hypercore_event<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, event_hash: &'life1 str, amount_wei: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<RsmUsdcDepositMatch>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Recover a still-pending Exchange.UsdcDeposit request for an already credited HyperCore event.

fn credited_wallet_for_hypercore_cash_event<'life0, 'life1, 'async_trait>( &'life0 self, event_hash: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<WalletAddress>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Return the wallet already credited for a HyperCore cash deposit event, if any.

fn non_crediting_hypercore_cash_event<'life0, 'life1, 'async_trait>( &'life0 self, event_hash: &'life1 str, amount_usdc: Decimal, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Return true when a HyperCore cash deposit event is already recorded as non-crediting.

fn apply_hypercore_cash_deposit<'life0, 'life1, 'async_trait>( &'life0 self, input: &'life1 HypercoreCashLedgerApply, ) -> Pin<Box<dyn Future<Output = Result<HypercoreCashLedgerApplyResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Apply a HyperCore cash deposit idempotently.

fn record_hypercore_cash_deposit_pending_margin_mode<'life0, 'life1, 'async_trait>( &'life0 self, input: &'life1 HypercoreCashLedgerApply, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persist a replayable cash deposit row when margin mode is temporarily unavailable.

impl SettlementReader for DatabaseHandler

fn is_settlement_ledger_applied_sync( &self, wallet: &WalletAddress, symbol: &str, ) -> Result<bool>

Check if a specific settlement has been applied to the ledger.

fn get_applied_settlement_symbols_sync( &self, wallet: &WalletAddress, symbols: &[String], ) -> Result<HashSet<String>>

Return the subset of symbols that have applied settlement payouts for a wallet.

fn get_total_fill_volume_sync(&self) -> Result<(i64, Decimal)>

Get total fill volume: (fill_count, total_notional).

impl SettlementWriter for DatabaseHandler

fn try_apply_settlement_sync( &self, wallet: &WalletAddress, symbol: &str, position_size: Decimal, settlement_price: Decimal, settlement_value: Decimal, margin_mode: MarginMode, event_ts_ms: i64, settlement_entry_price: Option<Decimal>, cost_basis: Option<Decimal>, net_pnl: Option<Decimal>, ) -> Result<SettlementResult>

Idempotent settlement audit: expiration row, payout row, and ledger event. Returns whether this was a new settlement or a duplicate replay.

fn observe_applied_settlement_sync( &self, wallet: &WalletAddress, symbol: &str, position_size: Decimal, settlement_price: Decimal, settlement_value: Decimal, margin_mode: MarginMode, settlement_entry_price: Option<Decimal>, cost_basis: Option<Decimal>, net_pnl: Option<Decimal>, ) -> Result<SettlementResult>

Read and validate an already-applied settlement without writing.

impl TierReader for DatabaseHandler

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

Get margin mode for a wallet, defaulting to Standard if no row exists.

fn get_existing_margin_mode_sync( &self, wallet: &WalletAddress, ) -> Result<Option<MarginMode>>

Get margin mode only if a tier row exists (returns None otherwise).

fn get_tier_defaults_sync( &self, tier_name: &str, ) -> Result<Option<TierDefaultsRecord>>

Load default rate limits for a tier name (e.g. “default”, “mm”).

fn get_user_tier_sync( &self, wallet: &WalletAddress, ) -> Result<Option<UserTierRecord>>

Load the full tier record for a wallet.

fn get_all_user_tiers_sync(&self) -> Result<Vec<UserTierRecord>>

Load all user tiers across all wallets.

impl TierWriter for DatabaseHandler

fn save_user_tier_sync(&self, update: &UserTierUpdate) -> Result<()>

Upsert a tier. None fields in UserTierUpdate are left unchanged in the DB.

fn set_margin_mode_sync( &self, wallet: &WalletAddress, margin_mode: MarginMode, ) -> Result<i64>

Set margin mode for a wallet. Returns the new version counter.

fn insert_margin_mode_if_missing_sync( &self, wallet: &WalletAddress, margin_mode: MarginMode, ) -> Result<Option<i64>>

Insert a tier row with margin mode only if one doesn’t exist. Returns the new version counter, or None if the row already existed.

fn delete_user_tier_sync(&self, wallet: &WalletAddress) -> Result<()>

Delete the tier row for a wallet.

impl TransactionSubmitterStore for DatabaseHandler

fn max_nonce_for_submitter_sync( &self, submitter: &SubmitterId, ) -> Result<Option<u64>>

fn record_submission_sync( &self, record: &SubmissionRecord, attempts: &[SubmissionAttemptRecord], ) -> Result<()>

fn update_submission_status_sync( &self, submitter: &SubmitterId, nonce: SubmittedNonce, status: SubmissionStatus, primary_tx_hash: Option<&str>, terminal_error: Option<&str>, ) -> Result<()>

fn list_pending_submissions_sync( &self, after_submission_id: i64, limit: i64, ) -> Result<Vec<PendingSubmissionRow>>

impl Transactional for DatabaseHandler

type Tx = DieselTransaction

fn begin_transaction(&self) -> Result<DieselTransaction>

impl ValidatorRsmStateReader for DatabaseHandler

fn get_validator_rsm_root_summary_sync( &self, environment: ValidatorRsmEnvironment, version: u64, ) -> Result<Option<ValidatorRsmRootSummary>>

fn get_validator_rsm_current_state_sync( &self, environment: ValidatorRsmEnvironment, ) -> Result<Option<ValidatorRsmCurrentState>>

fn get_validator_rsm_current_root_summary_sync( &self, environment: ValidatorRsmEnvironment, ) -> Result<Option<ValidatorRsmRootSummary>>

fn get_rsm_block_by_height_sync( &self, environment: ValidatorRsmEnvironment, height: u64, ) -> Result<Option<RsmBlockView>>

fn get_rsm_block_by_hash_sync( &self, environment: ValidatorRsmEnvironment, hash: [u8; 32], ) -> Result<Option<RsmBlockView>>

fn get_latest_rsm_block_sync( &self, environment: ValidatorRsmEnvironment, ) -> Result<Option<RsmBlockView>>

fn list_rsm_blocks_sync( &self, environment: ValidatorRsmEnvironment, from_height: Option<u64>, limit: u32, ) -> Result<Vec<RsmBlockView>>

fn get_rsm_block_commands_sync( &self, environment: ValidatorRsmEnvironment, height: u64, ) -> Result<Vec<RsmBlockCommand>>

fn get_rsm_block_data_sync( &self, environment: ValidatorRsmEnvironment, height: u64, ) -> Result<Option<RsmBlockData>, Error>

impl ValidatorRsmStateWriter for DatabaseHandler

fn save_validator_rsm_root_summary_sync( &self, summary: &NewValidatorRsmRootSummary, advance_current: bool, ) -> Result<()>

fn save_rsm_block_header_sync(&self, block: &NewRsmBlockHeader) -> Result<()>

fn save_rsm_block_commands_sync( &self, commands: &[NewRsmBlockCommand], ) -> Result<()>