feat(rfq): quote leftover capacity instead of rejecting size

- Change capacity check to scale down requests instead of rejecting with Size reason
- When input exceeds available capacity, quote the remaining available amount rather than inventory-reject
- Update test expectations: requests that previously rejected now receive quotes for leftover slices
- Allows the API to bundle multiple makers into a single taker quote when capacity is constrained
- Recalculate output, fee, and sell_amount for scaled-down input amounts
- Preserve inventory rejection only when zero capacity remains after reservations

Author: bnolens

.textile-monorepo-source

@@ -1 +1 @@
-86206091c13f44d3c3c78c9f3215782a1ed08253
+1d81a9f9f390d7c73df7ad5d4cdfcb467e9ca7d4

.textile-stitch-release-version

@@ -1 +1 @@
-0.1.195
+0.1.196

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "stitch-bot"
-version = "0.1.195"
+version = "0.1.196"
 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

@@ -858,14 +858,15 @@ mod tests {
         );
         let _ = sig;
 
-        // The quote's input is reserved: a second identical request would
-        // need 2 × 979902009 > the 1.5e9 capacity → inventory reject.
+        // The quote's input is reserved: a second identical request used to
+        // inventory-reject (2 × 979902009 > 1.5e9). It now quotes the leftover
+        // so the venue can bundle this slice with other makers.
         let reply = engine.respond(exact_input_request("rfq_2"), &prices).await;
-        let MakerFrame::QuoteReject(rej) = reply else {
-            panic!("expected an inventory reject, got {reply:?}");
+        let MakerFrame::QuoteResponse(resp) = reply else {
+            panic!("expected a leftover quote, got {reply:?}");
         };
-        assert_eq!(rej.reason, RejectReason::Inventory);
-        assert_eq!(engine.reservations.len(), 1);
+        assert_eq!(resp.buy_amount, "520097991");
+        assert_eq!(engine.reservations.len(), 2);
     }
 
     #[tokio::test]

src/rfq/mod.rs

@@ -234,13 +234,25 @@ pub fn decide_quote(
     let Some(capacity) = capacity else {
         return Err(RejectReason::Inventory);
     };
-    if input > capacity {
-        return Err(RejectReason::Size);
-    }
     let reserved = if bid { reserved_bid } else { reserved_ask };
-    if input > capacity.saturating_sub(reserved) {
+    let available = capacity.saturating_sub(reserved);
+    if available.is_zero() {
         return Err(RejectReason::Inventory);
     }
+    // The venue may ask for more than we can fill (stale levels, or a slice
+    // of a larger RFQ). Quote what remains instead of rejecting — the API
+    // bundles several makers into one taker quote.
+    let (input, output, fee, sell_amount) = if input > available {
+        let input = available;
+        let output = output_for_input(input);
+        let fee = fee_on(output, req.fee_bps);
+        if input.is_zero() || output.is_zero() || fee.is_zero() {
+            return Err(RejectReason::Size);
+        }
+        (input, output, fee, output + fee)
+    } else {
+        (input, output, fee, sell_amount)
+    };
 
     Ok(QuotePlan {
         bid,
@@ -436,23 +448,28 @@ mod tests {
     }
 
     #[test]
-    fn capacity_and_reservations_gate_with_distinct_reasons() {
-        // Bigger than configured capacity outright → size.
+    fn capacity_scales_down_instead_of_rejecting_size() {
+        // Bigger than configured capacity: quote the cap, don't reject.
         let mut req = request(COLLATERAL, DEBT);
         req.sell_amount = Some("100000000000".into()); // maker would pay ~98e9 > 5e9
-        assert_eq!(
-            decide(&book(), &req, 1.0, U256::ZERO, U256::ZERO),
-            Err(RejectReason::Size)
-        );
+        let plan = decide(&book(), &req, 1.0, U256::ZERO, U256::ZERO).unwrap();
+        assert_eq!(plan.input, U256::from(5_000_000_000u64));
+        assert!(plan.sell_amount < U256::from(100000000000u64));
 
-        // Fits capacity but not what's left after in-flight quotes → inventory.
+        // Fits capacity but nothing left after in-flight quotes → inventory.
         let mut req = request(COLLATERAL, DEBT);
-        req.sell_amount = Some("1000000000".into()); // maker pays ~0.98e9
-        let reserved_bid = U256::from(4_500_000_000u64); // 4.5e9 of 5e9 claimed
+        req.sell_amount = Some("1000000000".into());
+        let fully_reserved = U256::from(5_000_000_000u64);
         assert_eq!(
-            decide(&book(), &req, 1.0, reserved_bid, U256::ZERO),
+            decide(&book(), &req, 1.0, fully_reserved, U256::ZERO),
             Err(RejectReason::Inventory)
         );
+
+        // Partial reservation: quote what's left rather than inventory-reject.
+        let reserved_bid = U256::from(4_500_000_000u64); // 0.5e9 left
+        let plan = decide(&book(), &req, 1.0, reserved_bid, U256::ZERO).unwrap();
+        assert_eq!(plan.input, U256::from(500_000_000u64));
+
         // The ask side's reservations don't bleed into the bid check.
         assert!(decide(&book(), &req, 1.0, U256::ZERO, reserved_bid).is_ok());
     }
@@ -641,13 +658,25 @@ mod tests {
         ]));
         assert!(decide_quote(&wallet_book, &req, 1.0, U256::ZERO, U256::ZERO, &inv).is_ok());
 
-        // Reservations still eat the live balance.
+        // Reservations eat the live balance; leftover is still quoted.
+        let plan = decide_quote(
+            &wallet_book,
+            &req,
+            1.0,
+            U256::from(1_500_000_000u64),
+            U256::ZERO,
+            &inv,
+        )
+        .unwrap();
+        assert_eq!(plan.input, U256::from(500_000_000u64));
+
+        // Nothing left → inventory.
         assert_eq!(
             decide_quote(
                 &wallet_book,
                 &req,
                 1.0,
-                U256::from(1_500_000_000u64),
+                U256::from(2_000_000_000u64),
                 U256::ZERO,
                 &inv
             ),
@@ -676,9 +705,11 @@ mod tests {
             (debt, U256::from(100_000u64)),
             (collateral, U256::from(100_000u64)),
         ]));
+        let thin_plan = decide_quote(&exact, &req, 1.0, U256::ZERO, U256::ZERO, &thin).unwrap();
         assert_eq!(
-            decide_quote(&exact, &req, 1.0, U256::ZERO, U256::ZERO, &thin),
-            Err(RejectReason::Size)
+            thin_plan.input,
+            U256::from(100_000u64),
+            "thin wallet is quoted as a leftover slice, not size-rejected"
         );
         assert!(decide_quote(&exact, &req, 1.0, U256::ZERO, U256::ZERO, &inv).is_ok());
     }