Wire destination-aware max_sendable via find_route

 The reported fee budget is built from
route.get_total_fees(), which is what LDK itself would charge for
a send of that size. Slightly conservative: total_fees is computed
from the full balance so with the sent amount they will be less.
This provides a buffer and could be tweaked by iterating the estimate.

On top of total_fees the budget applies a multiplier. The chosen route
can fail at send time and LDK retries along a more expensive path. A
multiplier scales with the original route's cost so retries can
actually reach those alternatives. Exposed as
route_retry_fee_multiplier_bps so operators can trade reported max
sendable for payment success rate. Starting low to minimise headroom
left on the table; bump up if production retries surface
"insufficient fee budget" failures too often.

FixedAmount returns Err(FixedAmount { amount_msat }) because there's
nothing to estimate when the payee dictates the amount; the variant
carries the amount so callers don't re-extract it.

BOLT12 offers, LNURL-pay, and HRN destinations fall back to the
simple buffer for now. BOLT12 needs the invoice (not the offer) for
from_bolt12_invoice, which depends on the invoice fetch deferred
upstream. LNURL-pay and HRN need to resolve into a concrete invoice
first; that resolution will move into this module shortly.

BOLT11 round-trips through its bech32 string: bitcoin-payment-
instructions pins upstream rust-lightning's Bolt11Invoice while
ldk-node pulls the moneydevkit fork. Wire-compatible, distinct types.
A re-parse failure falls back to Buffer rather than panicking.

Author: amackillop

src/daemon/config.rs

@@ -96,6 +96,7 @@ struct SpliceSection {
 struct MaxSendableSection {
     fee_buffer_bps: Option<u16>,
     fee_buffer_floor_sats: Option<u64>,
+    route_retry_fee_multiplier_bps: Option<u16>,
 }
 
 pub struct MdkConfig {
@@ -190,6 +191,9 @@ pub fn load_config(path: &str) -> io::Result<MdkConfig> {
                 fee_buffer_floor_sats: s
                     .fee_buffer_floor_sats
                     .unwrap_or(defaults.fee_buffer_floor_sats),
+                route_retry_fee_multiplier_bps: s
+                    .route_retry_fee_multiplier_bps
+                    .unwrap_or(defaults.route_retry_fee_multiplier_bps),
             }
         }
         None => MaxSendableConfig::default(),

src/mdk/client.rs

@@ -17,7 +17,7 @@ use tokio_util::sync::CancellationToken;
 
 use crate::mdk::error::{MdkError, SpliceError};
 use crate::mdk::max_sendable::{
-    compute_estimate, ChannelSnapshot, MaxSendableConfig, MaxSendableError, MaxSendableEstimate,
+    self, ChannelSnapshot, MaxSendableConfig, MaxSendableError, MaxSendableEstimate,
 };
 use crate::mdk::mdk_api::client::MdkApiClient;
 use crate::mdk::mdk_api::types::{
@@ -146,27 +146,29 @@ impl MdkClient {
 
     /// Best-effort estimate of the largest amount that can flow out
     /// over Lightning right now, with routing-fee headroom subtracted.
-    /// Computed inline from `node.list_channels()` on every call so
-    /// the result reflects in-flight HTLCs and reserve as of *now*.
+    /// Recomputed from `node.list_channels()` on every call so the
+    /// result reflects in-flight HTLCs and reserve as of *now*.
     ///
-    /// `dest` is currently ignored — only the `None` (destination-agnostic
-    /// buffer) path is implemented.
+    /// `dest = None` returns a buffer-based estimate; `Some(_)`
+    /// drives `Node::find_route` and subtracts the real fees. See
+    /// [`crate::mdk::max_sendable`] for the full dispatch table.
     pub fn max_sendable(
         &self,
         dest: Option<&PaymentInstructions>,
     ) -> Result<MaxSendableEstimate, MaxSendableError> {
-        debug_assert!(
-            dest.is_none(),
-            "destination-aware max_sendable is not yet implemented"
-        );
-        let _ = dest;
         let snaps: Vec<ChannelSnapshot> = self
             .node
             .list_channels()
             .iter()
             .map(ChannelSnapshot::from)
             .collect();
-        compute_estimate(&snaps, &self.lsp_pubkey, &self.max_sendable_cfg)
+        max_sendable::compute_estimate(
+            dest,
+            &snaps,
+            &self.lsp_pubkey,
+            &self.max_sendable_cfg,
+            |rp| self.node.find_route(rp).map_err(|e| format!("{e}")),
+        )
     }
 
     /// Splice `amount_sats` of confirmed on-chain funds into the