implement max_onchain_amount

libs/sdk-bindings/src/breez_sdk.udl

@@ -33,7 +33,7 @@ enum LnUrlPayError {
     "PaymentFailed",
     "PaymentTimeout",
     "RouteNotFound",
-    "RouteTooExpensive",
+    "RouteTooExpensive",    
     "ServiceConnectivity",
 };
 
@@ -143,6 +143,7 @@ dictionary LNInvoice {
     u64 expiry;
     sequence<RouteHint> routing_hints;
     sequence<u8> payment_secret;
+    u64 min_final_cltv_expiry_delta;
 };
 
 dictionary UnspentTransactionOutput {

libs/sdk-core/src/backup.rs

@@ -307,7 +307,7 @@ impl BackupWorker {
                 Ok((new_version, data))
             }
             Err(e) => {
-                debug!("Optimistic sync failed, trying to sync remote changes {e}");
+                info!("Optimistic sync failed, trying to sync remote changes {e}");
                 // We need to sync remote changes and then retry the push
                 self.sync_remote_and_push(sync_dir, data, &mut last_sync_request_id)
                     .await

libs/sdk-core/src/breez_services.rs

@@ -672,6 +672,36 @@ impl BreezServices {
         Ok(res)
     }
 
+    /// Returns the max amount that can be sent on-chain using the send_onchain method.
+    /// The returned amount is the sum of the max amount that can be sent on each channel
+    /// minus the expected fees.
+    /// This is possible since the route to the swapper node is known in advance ans is expected
+    /// to consist of maximum 3 hops.
+    pub async fn max_onchain_payment(
+        &self,
+        _request: MaxOnchainPaymentRequest,
+    ) -> Result<MaxOnchainPaymentResponse> {
+        // fetch the last hop hints from the swapper
+        let last_hop = self.btc_send_swapper.last_hop_for_payment().await?;
+
+        // calculate the largest payment we can send over this route using maximum 3 hops
+        // as follows:
+        // User Node -> LSP Node -> Routing Node -> Swapper Node
+        let (max_to_pay, _) = self
+            .node_api
+            .max_amount_to_send(
+                Some(hex::decode(&last_hop.src_node_id)?),
+                swap_out::reverseswap::MAX_PAYMENT_PATH_HOPS,
+                Some(&last_hop),
+            )
+            .await?;
+
+        // Sum the max amount per channel and return the result
+        let total = max_to_pay.into_iter().map(|m| m.amount_msat).sum();
+
+        Ok(MaxOnchainPaymentResponse { total })
+    }
+
     /// Creates a reverse swap and attempts to pay the HODL invoice
     pub async fn send_onchain(
         &self,