Return fedimint sweep result

Author: AnthonyRonning

mutiny-core/src/lib.rs

@@ -411,6 +411,17 @@ impl MutinyInvoice {
     }
 }
 
+/// FedimintSweepResult is the result of how much was swept and the fees paid.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct FedimintSweepResult {
+    /// The final amount that was swept.
+    /// This should be the amount specified if it was not max.
+    pub amount: u64,
+
+    /// The total fees paid for the sweep.
+    pub fees: Option<u64>,
+}
+
 pub struct MutinyWalletConfigBuilder {
     xprivkey: ExtendedPrivKey,
     #[cfg(target_arch = "wasm32")]
@@ -1185,7 +1196,10 @@ impl<S: MutinyStorage> MutinyWallet<S> {
         })
     }
 
-    pub async fn sweep_federation_balance(&self, amount: Option<u64>) -> Result<(), MutinyError> {
+    pub async fn sweep_federation_balance(
+        &self,
+        amount: Option<u64>,
+    ) -> Result<FedimintSweepResult, MutinyError> {
         // Attempt to create federation invoice if available and below max amount
         let federation_ids = self.list_federation_ids().await?;
         if federation_ids.is_empty() {
@@ -1202,10 +1216,13 @@ impl<S: MutinyStorage> MutinyWallet<S> {
         // if the user provided amount, this is easy
         if let Some(amt) = amount {
             let inv = self.node_manager.create_invoice(amt).await?;
-            let _ = fedimint_client
+            let pay_res = fedimint_client
                 .pay_invoice(inv.bolt11.expect("create inv had one job"), vec![])
                 .await?;
-            return Ok(());
+            return Ok(FedimintSweepResult {
+                amount: amt,
+                fees: pay_res.fees_paid,
+            });
         }
 
         // If no amount, figure out the amount to send over
@@ -1219,29 +1236,43 @@ impl<S: MutinyStorage> MutinyWallet<S> {
         let fees = fedimint_client.gateway_fee().await?;
         let amt = max_spendable_amount(current_balance, fees.clone())
             .map_or(Err(MutinyError::InsufficientBalance), Ok)?;
-        log_info!(self.logger, "max spendable: {}", amt);
+        log_debug!(self.logger, "max spendable: {}", amt);
 
         // try to get an invoice for this exact amount
         let inv = self.node_manager.create_invoice(amt).await?;
 
+        // check if we can afford that invoice
         let inv_amt = inv.amount_sats.ok_or(MutinyError::BadAmountError)?;
-        let inv_to_pay = if inv_amt > amt {
-            let new_amt = inv_amt - (inv_amt - amt);
-            log_info!(self.logger, "adjusting amount to swap to: {}", amt);
-            self.node_manager.create_invoice(new_amt).await?
+        let first_invoice_amount = if inv_amt > amt {
+            log_debug!(self.logger, "adjusting amount to swap to: {}", amt);
+            inv_amt - (inv_amt - amt)
+        } else {
+            inv_amt
+        };
+
+        // if invoice amount changed, create a new invoice
+        let inv_to_pay = if first_invoice_amount != inv_amt {
+            self.node_manager
+                .create_invoice(first_invoice_amount)
+                .await?
         } else {
             inv.clone()
         };
 
-        log_info!(self.logger, "attempting payment from fedimint client");
-        let _ = fedimint_client
+        log_debug!(self.logger, "attempting payment from fedimint client");
+        let mut final_result = FedimintSweepResult {
+            amount: first_invoice_amount,
+            fees: None,
+        };
+        let first_invoice_res = fedimint_client
             .pay_invoice(inv_to_pay.bolt11.expect("create inv had one job"), vec![])
             .await?;
+        final_result.fees = first_invoice_res.fees_paid;
 
         // pay_invoice returns invoice if Succeeded or Err if something else
         // it's safe to assume that it went through and we can check remaining balance
         let remaining_balance = fedimint_client.get_balance().await?;
-        log_info!(
+        log_debug!(
             self.logger,
             "remaining fedimint balance: {}",
             remaining_balance
@@ -1250,7 +1281,7 @@ impl<S: MutinyStorage> MutinyWallet<S> {
             // the fee for existing channel is voltage 1 sat + base fee + ppm
             let remaining_balance_minus_fee = max_spendable_amount(remaining_balance - 1, fees);
             if remaining_balance_minus_fee.is_none() {
-                return Ok(());
+                return Ok(final_result);
             }
             let remaining_balance_minus_fee = remaining_balance_minus_fee.unwrap();
 
@@ -1263,8 +1294,14 @@ impl<S: MutinyStorage> MutinyWallet<S> {
                 .pay_invoice(inv.bolt11.expect("create inv had one job"), vec![])
                 .await
             {
-                Ok(_) => {
-                    log_info!(self.logger, "paid remaining balance")
+                Ok(r) => {
+                    log_debug!(self.logger, "paid remaining balance");
+                    final_result.amount += remaining_balance_minus_fee;
+                    final_result.fees = final_result.fees.map_or(r.fees_paid, |val| {
+                        r.fees_paid
+                            .map(|add_val| val + add_val)
+                            .map_or(Some(val), |_| None)
+                    });
                 }
                 Err(e) => {
                     // Don't want to return this error since it's just "incomplete",
@@ -1274,7 +1311,7 @@ impl<S: MutinyStorage> MutinyWallet<S> {
             }
         }
 
-        Ok(())
+        Ok(final_result)
     }
 
     async fn create_lightning_invoice(

mutiny-wasm/src/lib.rs

@@ -997,8 +997,11 @@ impl MutinyWallet {
     }
 
     /// Sweep the federation balance into a lightning channel
-    pub async fn sweep_federation_balance(&self, amount: Option<u64>) -> Result<(), MutinyJsError> {
-        Ok(self.inner.sweep_federation_balance(amount).await?)
+    pub async fn sweep_federation_balance(
+        &self,
+        amount: Option<u64>,
+    ) -> Result<FedimintSweepResult, MutinyJsError> {
+        Ok(self.inner.sweep_federation_balance(amount).await?.into())
     }
 
     /// Closes a channel with the given outpoint.

mutiny-wasm/src/models.rs

@@ -1074,6 +1074,31 @@ impl From<mutiny_core::Plan> for Plan {
     }
 }
 
+/// FedimintSweepResult is the result of how much was swept and the fees paid.
+#[derive(Serialize, Deserialize, Clone, Eq, PartialEq)]
+#[wasm_bindgen]
+pub struct FedimintSweepResult {
+    pub amount: u64,
+    pub fees: Option<u64>,
+}
+
+#[wasm_bindgen]
+impl FedimintSweepResult {
+    #[wasm_bindgen(getter)]
+    pub fn value(&self) -> JsValue {
+        JsValue::from_serde(&serde_json::to_value(self).unwrap()).unwrap()
+    }
+}
+
+impl From<mutiny_core::FedimintSweepResult> for FedimintSweepResult {
+    fn from(m: mutiny_core::FedimintSweepResult) -> Self {
+        FedimintSweepResult {
+            amount: m.amount,
+            fees: m.fees,
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[wasm_bindgen]
 pub enum BudgetPeriod {