Restore small BTC-family swap reserves

Author: 0xh3rman

crates/swapper/src/chainflip/provider.rs

@@ -349,7 +349,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::SwapperQuoteAsset;
+    use crate::{Options, SwapperQuoteAsset};
     use primitives::AssetId;
 
     #[test]
@@ -378,13 +378,18 @@ mod tests {
         let request = QuoteRequest {
             from_asset: SwapperQuoteAsset::from(AssetId::from_chain(Chain::Bitcoin)),
             to_asset: SwapperQuoteAsset::from(AssetId::from_chain(Chain::Ethereum)),
+            value: "89100".to_string(),
+            options: Options {
+                use_max_amount: true,
+                ..Default::default()
+            },
             ..QuoteRequest::mock(Chain::Bitcoin, None)
         };
 
         let quote_request = build_quote_request(&request).unwrap();
 
-        assert_eq!(quote_request.from_value, "1000000");
-        assert_eq!(quote_request.quote_request.amount, "1000000");
+        assert_eq!(quote_request.from_value, "74100");
+        assert_eq!(quote_request.quote_request.amount, "74100");
         assert_eq!(quote_request.quote_request.src_chain, "Bitcoin");
         assert_eq!(quote_request.quote_request.src_asset, "BTC");
         assert_eq!(quote_request.quote_request.dest_chain, "Ethereum");

crates/swapper/src/fees/reserve.rs

@@ -6,6 +6,7 @@ use crate::{QuoteRequest, SwapperError};
 
 pub static RESERVED_NATIVE_FEES: LazyLock<HashMap<Chain, &'static str>> = LazyLock::new(|| {
     HashMap::from([
+        // Gas holdback for max-send source transactions.
         (Chain::Near, "50000000000000000000000"), // 0.05 NEAR
         (Chain::Ethereum, "1000000000000000"),    // 0.001 ETH
         (Chain::Arbitrum, "300000000000000"),     // 0.0003 ARB ETH
@@ -20,15 +21,10 @@ pub static RESERVED_NATIVE_FEES: LazyLock<HashMap<Chain, &'static str>> = LazyLo
         (Chain::Solana, "20000"),                 // 0.00002 SOL
         (Chain::Ton, "20000000"),                 // 0.02 TON
         (Chain::Tron, "20000000"),                // 20 TRX
-        (Chain::Bitcoin, "40000"),                // 0.0004 BTC
-        (Chain::Zcash, "1000000"),                // 0.01 ZEC
-        (Chain::Doge, "500000000"),               // 5 DOGE
         (Chain::Xrp, "2000000"),                  // 2 XRP
         (Chain::Cardano, "2000000"),              // 2 ADA
         (Chain::Aptos, "20000000"),               // 0.2 APT
         (Chain::Stellar, "100000"),               // 0.01 XLM
-        (Chain::Litecoin, "100000"),              // 0.001 LTC
-        (Chain::BitcoinCash, "100000"),           // 0.001 BCH
         (Chain::Monad, "5000000000000000"),       // 0.005 MON
         (Chain::XLayer, "5000000000000000"),      // 0.005 OKB
         (Chain::Plasma, "5000000000000000"),      // 0.005 XPL
@@ -38,6 +34,12 @@ pub static RESERVED_NATIVE_FEES: LazyLock<HashMap<Chain, &'static str>> = LazyLo
         (Chain::Injective, "1300000000000000"),   // 0.0013 INJ
         (Chain::Sei, "1300000"),                  // 1.3 SEI
         (Chain::Noble, "25000"),                  // 0.025 USDC
+        // UTXO fee-vs-slippage buffer for amount-sensitive max swaps.
+        (Chain::Bitcoin, "15000"),     // ~300 vB * ~50 sat/vB peak
+        (Chain::Litecoin, "15000"),    // ~300 vB * ~50 lit/vB peak
+        (Chain::BitcoinCash, "10000"), // ~300 B * ~30 sat/B peak
+        (Chain::Doge, "10000000"),     // 0.1 DOGE
+        (Chain::Zcash, "30000"),       // 3x ZIP-317 marginal fee
     ])
 });
 
@@ -65,3 +67,43 @@ pub fn quote_value_after_reserve_by_chain(request: &QuoteRequest) -> Result<Stri
     };
     quote_value_after_reserve(request, reserved)
 }
+
+#[cfg(test)]
+mod tests {
+    use primitives::AssetId;
+
+    use super::*;
+    use crate::{Options, SwapperQuoteAsset};
+
+    #[test]
+    fn btc_family_chains_have_buffer_reserve() {
+        assert_eq!(reserved_tx_fees(Chain::Bitcoin), Some("15000"));
+        assert_eq!(reserved_tx_fees(Chain::Litecoin), Some("15000"));
+        assert_eq!(reserved_tx_fees(Chain::BitcoinCash), Some("10000"));
+        assert_eq!(reserved_tx_fees(Chain::Doge), Some("10000000"));
+        assert_eq!(reserved_tx_fees(Chain::Zcash), Some("30000"));
+    }
+
+    #[test]
+    fn btc_max_quote_applies_reserve() {
+        let request = QuoteRequest {
+            from_asset: SwapperQuoteAsset::from(AssetId::from_chain(Chain::Bitcoin)),
+            to_asset: SwapperQuoteAsset::from(AssetId::from_chain(Chain::Solana)),
+            wallet_address: "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4".into(),
+            destination_address: "11111111111111111111111111111111".into(),
+            value: "89100".to_string(),
+            options: Options {
+                use_max_amount: true,
+                ..Default::default()
+            },
+        };
+
+        assert_eq!(quote_value_after_reserve_by_chain(&request).unwrap(), "74100");
+    }
+
+    #[test]
+    fn btc_reserve_exceeds_typical_planner_fee() {
+        let reserve: u64 = reserved_tx_fees(Chain::Bitcoin).unwrap().parse().unwrap();
+        assert!(reserve >= 12_000, "Bitcoin reserve {reserve} too small to absorb peak-fee planner cost");
+    }
+}

crates/swapper/src/near_intents/provider.rs

@@ -395,14 +395,14 @@ mod tests {
 
     #[test]
     fn max_quote_keeps_transfer_amount() {
-        let mut request = QuoteRequest::mock(Chain::Tron, None);
+        let mut request = QuoteRequest::mock(Chain::Bitcoin, None);
         request.to_asset = SwapperQuoteAsset::from(AssetId::from_chain(Chain::Near));
-        request.value = "37000000".to_string();
+        request.value = "89100".to_string();
         request.options.use_max_amount = true;
 
         let quote_request = NearIntents::<RpcClient>::build_quote_request(&request, SwapType::FlexInput, true).unwrap();
 
-        assert_eq!(quote_request.amount, "37000000");
+        assert_eq!(quote_request.amount, "89100");
     }
 
     #[test]

crates/swapper/src/thorchain/provider.rs

@@ -243,6 +243,24 @@ mod tests {
         assert!(has_zcash);
     }
 
+    #[test]
+    fn test_quote_input_value_bitcoin_max_passes_value_through() {
+        let from_asset = THORChainAsset::from_asset_id(Chain::Bitcoin.as_ref()).unwrap();
+        let request = QuoteRequest {
+            from_asset: SwapperQuoteAsset::from(Chain::Bitcoin.as_asset_id()),
+            to_asset: SwapperQuoteAsset::from(Chain::Solana.as_asset_id()),
+            wallet_address: "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4".to_string(),
+            destination_address: "11111111111111111111111111111111".to_string(),
+            value: "89100".to_string(),
+            options: Options {
+                use_max_amount: true,
+                ..Default::default()
+            },
+        };
+
+        assert_eq!(quote_input_value(&from_asset, &request).unwrap(), "89100");
+    }
+
     #[tokio::test]
     async fn test_get_quote_data_uses_quote_from_value() {
         let provider = Arc::new(ProviderMock::new(String::new()));