fix: handle max amount calculations in calculate_total_fee

When users try to calculate fees for amounts close to their total balance, calculate_total_fee` would previously throw `InsufficientFunds`. This fix detects when the requested amount is within the spendable balance and automatically calculates the fee as if sending all available funds, while retaining the anchor channel reserve.

- Detect near-full-balance send attempts and apply max-spend logic
- Avoids InsufficientFunds error in calculate_total_fee when near the total spendable balance
- Retains anchor channel reserve to ensure safety and correctness
- Updates bindings
- Bumps version to 0.6.1-rc.5

Author: coreyphillips

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ldk-node"
-version = "0.6.1-rc.4"
+version = "0.6.1-rc.5"
 authors = ["Elias Rohrer <[email protected]>"]
 homepage = "https://lightningdevkit.org/"
 license = "MIT OR Apache-2.0"

Package.swift

@@ -3,8 +3,8 @@
 
 import PackageDescription
 
-let tag = "v0.6.1-rc.4"
-let checksum = "827824d292db54baf9c9ac5b2de2ed84f6c93e22a8fe64b838ca85bb0753d495"
+let tag = "v0.6.1-rc.5"
+let checksum = "8834dd706cc3393202f27f4ac9eb0144c00a7804dbf9004cf179ff9f997e6de3"
 let url = "https://github.com/synonymdev/ldk-node/releases/download/\(tag)/LDKNodeFFI.xcframework.zip"
 
 let package = Package(

bindings/kotlin/ldk-node-android/README.md

@@ -31,7 +31,7 @@ Publishing new version guide.
     - add dependency in `libs.versions.toml`:
         ```toml
         # by tag
-        ldk-node-android = { module = "com.github.synonymdev:ldk-node", version = "v0.6.1-rc.4"
+        ldk-node-android = { module = "com.github.synonymdev:ldk-node", version = "v0.6.1-rc.5"
 
         # or by branch
         ldk-node-android = { module = "com.github.synonymdev:ldk-node", version = "main-SNAPSHOT"

bindings/kotlin/ldk-node-android/gradle.properties

@@ -2,4 +2,4 @@ org.gradle.jvmargs=-Xmx1536m
 android.useAndroidX=true
 android.enableJetifier=true
 kotlin.code.style=official
-libraryVersion=v0.6.1-rc.4
+libraryVersion=v0.6.1-rc.5

bindings/kotlin/ldk-node-android/lib/src/main/jniLibs/arm64-v8a/libldk_node.so

@@ -157,10 +157,16 @@ impl OnchainPayment {
 	/// The calculation respects any on-chain reserve requirements and validates that sufficient
 	/// funds are available, just like [`send_to_address`].
 	///
+	/// **Special handling for maximum amounts:** If the specified amount would result in
+	/// insufficient funds due to fees, but is within the spendable balance, this method will
+	/// automatically calculate the fee for sending all available funds while retaining the
+	/// anchor channel reserve. This allows users to calculate fees when trying to send
+	/// their maximum spendable balance.
+	///
 	/// # Arguments
 	///
 	/// * `address` - The Bitcoin address to send to
-	/// * `amount_sats` - The amount to send in satoshis
+	/// * `amount_sats` - The amount to send in satoshis (or total balance for max send)
 	/// * `fee_rate` - Optional fee rate to use (if None, will estimate based on current network conditions)
 	/// * `utxos_to_spend` - Optional list of specific UTXOs to use for the transaction
 	///
@@ -176,6 +182,7 @@ impl OnchainPayment {
 	/// * [`Error::WalletOperationFailed`] - If fee calculation fails
 	///
 	/// [`send_to_address`]: Self::send_to_address
+	/// [`BalanceDetails::total_onchain_balance_sats`]: crate::balance::BalanceDetails::total_onchain_balance_sats
 	pub fn calculate_total_fee(
 		&self, address: &bitcoin::Address, amount_sats: u64, fee_rate: Option<FeeRate>,
 		utxos_to_spend: Option<Vec<SpendableUtxo>>,
@@ -187,18 +194,43 @@ impl OnchainPayment {
 
 		let cur_anchor_reserve_sats =
 			crate::total_anchor_channels_reserve_sats(&self.channel_manager, &self.config);
-		let send_amount =
-			OnchainSendAmount::ExactRetainingReserve { amount_sats, cur_anchor_reserve_sats };
+		
+		// Get current balances
+		let (_total_balance, spendable_balance) = self.wallet.get_balances(cur_anchor_reserve_sats)
+			.unwrap_or((0, 0));
+		
+		// First try with the exact amount
 		let outpoints = utxos_to_spend.map(|utxos| utxos.into_iter().map(|u| u.outpoint).collect());
 		let fee_rate_opt = maybe_map_fee_rate_opt!(fee_rate);
-
-		self.wallet.calculate_transaction_fee(
+		
+		// Try calculating with exact amount first
+		let send_amount = OnchainSendAmount::ExactRetainingReserve { amount_sats, cur_anchor_reserve_sats };
+		let result = self.wallet.calculate_transaction_fee(
 			address,
 			send_amount,
 			fee_rate_opt,
-			outpoints,
+			outpoints.clone(),
 			&self.channel_manager,
-		)
+		);
+		
+		// If we get InsufficientFunds and the amount is within the spendable balance,
+		// try calculating as if sending all available funds
+		if matches!(result, Err(Error::InsufficientFunds)) && amount_sats <= spendable_balance {
+			// Try with AllRetainingReserve to calculate the fee for sending all
+			let all_retaining = OnchainSendAmount::AllRetainingReserve { cur_anchor_reserve_sats };
+			if let Ok(fee) = self.wallet.calculate_transaction_fee(
+				address,
+				all_retaining,
+				fee_rate_opt,
+				outpoints.clone(),
+				&self.channel_manager,
+			) {
+				// Return the fee for sending all available funds
+				return Ok(fee);
+			}
+		}
+		
+		result
 	}
 
 	/// Send an on-chain payment to the given address.