Struct RfqManager 

pub struct RfqManager {
    active_rfqs: DashMap<Uuid, RfqRecord>,
    qp_cache: Arc<QuoteProviderCache>,
    qp_sessions: Arc<dyn QpSessionRegistry>,
    rfq_sender: Sender<RfqExecuteRequest>,
    db: Option<Arc<dyn RfqWriter>>,
    config: RfqConfig,
}

Manages RFQ lifecycle: creation, QP fan-out, quote collection, acceptance.

Fields

active_rfqs: DashMap<Uuid, RfqRecord>

qp_cache: Arc<QuoteProviderCache>

qp_sessions: Arc<dyn QpSessionRegistry>

rfq_sender: Sender<RfqExecuteRequest>

db: Option<Arc<dyn RfqWriter>>

config: RfqConfig

Implementations

impl RfqManager

pub fn new( qp_cache: Arc<QuoteProviderCache>, qp_sessions: Arc<dyn QpSessionRegistry>, rfq_sender: Sender<RfqExecuteRequest>, config: RfqConfig, ) -> Self

pub fn min_improvement_tick(&self) -> Decimal

fn persist_status(&self, rfq_id: &Uuid, status: RfqStatus)

Persist an RFQ status change to the rfq_records table. Non-fatal on failure — logs a warning and keeps going so in-memory state transitions stay responsive even if the DB hiccups. Callers MUST NOT hold a DashMap lock (e.g. get_mut guard or alter_all closure) while invoking this; drop the entry first.

pub fn set_db(&mut self, handler: Arc<dyn RfqWriter>)

Set the persistence writer for RFQ records and quotes.

pub async fn submit_rfq( &self, rfq_id: Uuid, taker_wallet: WalletAddress, taker_signer: WalletAddress, legs: Vec<RfqLeg>, legs_hash: [u8; 32], taker_signature: String, taker_nonce: u64, auto_accept_limit: Option<Decimal>, ) -> Result<RfqRecord, String>

Submit a new RFQ from a taker.

pub async fn submit_rpi_auction( &self, request: SubmitRpiAuction, ) -> Result<RfqRecord, String>

pub fn handle_qp_response( &self, rfq_id: Uuid, quote: QpQuote, ) -> Result<HandleQpResponseResult, String>

Handle a firm quote response from a QP.

No margin check here. Quotes are short-lived and non-binding until accepted, so margin state can change between quote time and acceptance (new fills, deposits, other RFQs landing). The authoritative SPAN margin check on both taker and QP runs in plan_rfq_execution at accept time, which cannot be skipped. Adding a check here would add engine load on every incoming quote for a result that’s immediately stale.

pub fn record_qp_invalid_response(&self, rfq_id: Uuid, qp_wallet: WalletAddress)

pub async fn accept_quote( &self, rfq_id: Uuid, quote_id: Uuid, taker_wallet: WalletAddress, taker_signature: String, taker_signer: WalletAddress, taker_nonce: u64, ) -> Result<RfqExecuteResult, String>

Accept a quote. Uses get_mut() for atomic state transition (prevents double-accept). DashMap::get_mut() holds an exclusive shard lock for the key, so the read-check-write within the block is atomic with respect to other accesses to the same key.

pub async fn auto_accept_quote( &self, rfq_id: Uuid, quote_id: Uuid, taker_signature: String, ) -> Result<RfqExecuteResult, String>

Execute an auto-accepted RFQ quote. Called from a spawned task after handle_qp_response returns AutoExecuted. The taker already authorized execution via the SubmitAutoExecuteRfq EIP-712 signature, so no separate accept signature is needed.

pub fn record_qp_decline(&self, rfq_id: Uuid, qp_wallet: WalletAddress)

pub async fn wait_for_rpi_auction_close( &self, rfq_id: Uuid, ) -> Result<RfqRecord, String>

pub fn rpi_candidate_quote_ids( &self, rfq_id: &Uuid, ) -> Result<Vec<Uuid>, String>

pub async fn execute_rpi_quote( &self, rfq_id: Uuid, quote_id: Uuid, taker_signature: String, ) -> Result<RfqExecuteResult, String>

pub fn mark_rpi_fallback_to_book(&self, rfq_id: &Uuid)

pub fn get_rfq(&self, rfq_id: &Uuid) -> Option<RfqRecord>

Get an RFQ record by ID.

pub fn get_history(&self, wallet: &WalletAddress) -> Vec<RfqRecord>

Get RFQ history for a wallet.

pub fn start_cleanup_task(self: &Arc<Self>, shutdown: Receiver<()>)

Start a background cleanup task that expires stale RFQs.

fn cleanup_expired(&self)

Expire stale RFQs and evict old terminal records.