feat(rfq): release inventory when quote expires unaccepted

- Add immediate release mechanism for quotes that expire without taker acceptance, preventing ghost reservations from blocking subsequent requests on the same side
- Implement `Reservations::release()` to drop RFQ claims immediately when venue reports `quoteExpired`, complementing the existing time-based expiry logic
- Update `QuoteExpired` handler to release inventory and log appropriately, distinguishing from other quote loss scenarios
- Add test coverage for inventory release and subsequent request sizing after expiry
- Update module documentation to explain the special handling of `quoteExpired` frames

Author: bnolens

.textile-monorepo-source

@@ -1 +1 @@
-2ff86a428b0ca3562ad5bb4172c7f26044dec4d3
+6790dfc0d936d8eb71987d1f45db2ad3deddc75b

.textile-stitch-release-version

@@ -1 +1 @@
-0.1.199
+0.1.200

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "stitch-bot"
-version = "0.1.199"
+version = "0.1.200"
 edition = "2021"
 description = "Stitch — Textile filler-network operator bot; market-makes the filler order book with signed UniswapX limit orders."
 license = "AGPL-3.0-or-later"

Cargo.toml

@@ -491,7 +491,14 @@ impl Engine {
                 None
             }
             VenueFrame::QuoteExpired(e) => {
-                debug!(rfq_id = %e.rfq_id, "quote expired unselected");
+                // The taker's accept window lapsed without a submit. Drop the
+                // claim now so the next request on this side is not sized
+                // against a quote the venue has already un-counted.
+                if self.reservations.release(&e.rfq_id) {
+                    info!(rfq_id = %e.rfq_id, "quote expired unaccepted; inventory released");
+                } else {
+                    debug!(rfq_id = %e.rfq_id, "quote expired unaccepted; no local reservation");
+                }
                 None
             }
             VenueFrame::Challenge(_) | VenueFrame::SessionAccepted(_) => {
@@ -749,6 +756,7 @@ async fn inventory_loop(
 
 #[cfg(test)]
 mod tests {
+    use super::wire::QuoteExpiredFrame;
     use super::*;
     use crate::config::RfqCapacity;
     use crate::quote::Spread;
@@ -921,6 +929,33 @@ mod tests {
         assert_eq!(cache.get("http://feed").unwrap().price, 2.0);
     }
 
+    #[tokio::test]
+    async fn quote_expired_releases_inventory_so_the_next_request_can_fill() {
+        let mut engine = test_engine();
+        let prices = fresh_prices();
+        let first = engine.respond(exact_input_request("rfq_1"), &prices).await;
+        assert!(matches!(first, MakerFrame::QuoteResponse(_)));
+        assert_eq!(engine.reservations.len(), 1);
+
+        let none = engine
+            .dispatch(
+                VenueFrame::QuoteExpired(QuoteExpiredFrame {
+                    rfq_id: "rfq_1".into(),
+                }),
+                &prices,
+            )
+            .await;
+        assert!(none.is_none());
+        assert!(engine.reservations.is_empty());
+
+        let second = engine.respond(exact_input_request("rfq_2"), &prices).await;
+        let MakerFrame::QuoteResponse(resp) = second else {
+            panic!("expected a full-size quote after expiry release, got {second:?}");
+        };
+        assert_eq!(resp.buy_amount, "979902009");
+        assert_eq!(engine.reservations.len(), 1);
+    }
+
     #[tokio::test]
     async fn stale_or_missing_feeds_reject_and_publish_no_levels() {
         let mut engine = test_engine();

src/rfq/mod.rs

@@ -6,8 +6,12 @@
 //! deadline passes — INCLUDING quotes the venue reports as lost
 //! (`lost_price`): a losing quote is still a valid signed order the winner's
 //! failure could route to, so its reservation holds until `deadline + skew`,
-//! never until the loss notice. Releases are therefore purely time-based; the
-//! venue's result frames are informational.
+//! never until the loss notice.
+//!
+//! `quoteExpired` is the exception: the taker was handed the winning quote
+//! and its accept window lapsed without a submit. The venue un-counts that
+//! order at the same moment, so this ledger must drop it or the next request
+//! on the same side keeps seeing a ghost reservation.
 
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
@@ -146,6 +150,17 @@ impl Reservations {
             .fold(U256::ZERO, |sum, r| sum.saturating_add(r.input))
     }
 
+    /// Drop one RFQ's claim immediately. Used when the venue says the
+    /// winning quote expired unaccepted (`quoteExpired`). Missing id is a
+    /// no-op so a duplicate or late frame cannot break the ledger.
+    pub fn release(&mut self, rfq_id: &str) -> bool {
+        let gone = self.by_rfq.remove(rfq_id).is_some();
+        if gone {
+            self.persist();
+        }
+        gone
+    }
+
     /// Drop entries past their release time. Called on the 1s levels tick so
     /// the map can't grow unboundedly between quote bursts.
     pub fn prune(&mut self, now_secs: u64) {
@@ -249,6 +264,18 @@ mod tests {
         assert_eq!(r.reserved("cngn-usdc", true, 0), U256::from(60u64));
     }
 
+    #[test]
+    fn quote_expired_releases_immediately_not_at_deadline_plus_skew() {
+        let mut r = Reservations::new();
+        r.reserve("rfq_1", "cngn-usdc", true, U256::from(500u64), 1_000);
+        assert!(r.release("rfq_1"));
+        assert_eq!(r.reserved("cngn-usdc", true, 0), U256::ZERO);
+        assert!(!r.release("rfq_1"), "duplicate release is a no-op");
+        r.reserve("rfq_2", "cngn-usdc", false, U256::from(9u64), 1_000);
+        assert!(r.release("rfq_2"));
+        assert_eq!(r.reserved("cngn-usdc", false, 0), U256::ZERO);
+    }
+
     #[test]
     fn prune_reclaims_expired_entries() {
         let mut r = Reservations::new();
@@ -314,6 +341,17 @@ mod tests {
         let _ = std::fs::remove_dir_all(path.parent().unwrap());
     }
 
+    #[test]
+    fn persist_release_drops_the_entry_from_disk() {
+        let path = tmp_path("release");
+        let mut live = Reservations::with_persist_path(&path);
+        live.reserve("rfq_1", "cngn-usdc", true, U256::from(500u64), 1_000);
+        assert!(live.release("rfq_1"));
+        let restored = Reservations::load(&path, 0).unwrap();
+        assert!(restored.is_empty());
+        let _ = std::fs::remove_dir_all(path.parent().unwrap());
+    }
+
     #[test]
     fn a_missing_reservations_file_is_an_empty_ledger() {
         let path = tmp_path("missing");