Merge #509

509: Update on-chain balance immediately after channel closure r=luckysori a=luckysori

Fixes #461.

The coins are correctly moved to a pending state, like we do with any other on-chain transaction.

The user is also informed about what to expect when closing the channel.

It's important to note that if the user runs into a force-closure for some other reason, the coins will also go into a pending state and be reflected in the overall on-chain balance, but it will take _hundreds_ of confirmations for the coins to be confirmed.

![image](https://user-images.githubusercontent.com/9418575/205271194-a34a118e-2ac5-45d8-a6a7-b511e15f5528.png)


Co-authored-by: Lucas Soriano del Pino <lucas_soriano@fastmail.com>

Author: bors[bot]

Cargo.lock

@@ -319,8 +319,8 @@ Future<void> callGetBalances() async {
   try {
     final balance = await api.getBalance();
     bitcoinBalance.update(Amount(balance.onChain.confirmed), Amount(balance.onChain.trustedPending),
-        Amount(balance.onChain.untrustedPending));
-    lightningBalance.update(Amount(balance.offChain));
+        Amount(balance.onChain.untrustedPending), Amount(balance.offChain.pendingClose));
+    lightningBalance.update(Amount(balance.offChain.available));
     FLog.trace(text: 'Successfully retrieved wallet balances');
   } catch (error) {
     FLog.error(text: "Failed to get balances:" + error.toString());

lib/main.dart

@@ -14,19 +14,22 @@ class BitcoinBalance extends ChangeNotifier {
   Amount confirmed = Amount.zero;
   Amount pendingInternal = Amount.zero;
   Amount pendingExternal = Amount.zero;
+  Amount pendingChannelClose = Amount.zero;
 
   Amount pending() {
-    return Amount(pendingExternal.asSats + pendingInternal.asSats);
+    return Amount(pendingExternal.asSats + pendingInternal.asSats + pendingChannelClose.asSats);
   }
 
   Amount total() {
     return Amount(confirmed.asSats + pending().asSats);
   }
 
-  void update(Amount confirmed, Amount pendingInternal, Amount pendingExternal) {
+  void update(Amount confirmed, Amount pendingInternal, Amount pendingExternal,
+      Amount pendingChannelClose) {
     this.confirmed = confirmed;
     this.pendingInternal = pendingInternal;
     this.pendingExternal = pendingExternal;
+    this.pendingChannelClose = pendingChannelClose;
 
     super.notifyListeners();
   }

lib/models/balance_model.dart

@@ -53,6 +53,9 @@ class _CloseChannelState extends State<CloseChannel> {
                       TextSpan(
                           text:
                               "Closing the channel will send ${closeAmount.value} sats to your 10101 on-chain wallet.\n\n"),
+                      const TextSpan(
+                          text:
+                              "It will take at least 2 blocks after the publication of the channel close transaction for your coins to be confirmed by your on-chain wallet.\n\n"),
                       const TextSpan(
                           text:
                               "Once the channel is closed, you will have to open a new one if you want to continue using your wallet for Lightning payments and trading.")
@@ -90,7 +93,7 @@ class _CloseChannelState extends State<CloseChannel> {
   }
 
   Future<void> closeChannel() async {
-    FLog.info(text: "Closing channel with outbound liquidity of " + closeAmount.toString());
+    FLog.info(text: "Closing channel with outbound liquidity of " + closeAmount.value.toString());
 
     try {
       await api.closeChannel();

lib/wallet/close_channel.dart

@@ -63,7 +63,7 @@ pub struct Wallet {
 #[derive(Debug, Clone, Serialize)]
 pub struct Balance {
     pub on_chain: OnChain,
-    pub off_chain: u64,
+    pub off_chain: OffChain,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -76,6 +76,12 @@ pub struct OnChain {
     pub confirmed: u64,
 }
 
+#[derive(Debug, Clone, Serialize)]
+pub struct OffChain {
+    pub available: u64,
+    pub pending_close: u64,
+}
+
 impl Wallet {
     pub fn new(data_dir: &Path) -> Result<Wallet> {
         let network = config::network();
@@ -140,7 +146,7 @@ impl Wallet {
 
     pub fn get_balance(&self) -> Result<Balance> {
         let bdk_balance = self.get_bdk_balance()?;
-        let ldk_balance = self.get_ldk_balance();
+        let off_chain = self.get_ldk_balance()?;
         Ok(Balance {
             // subtract the ldk balance from the bdk balance as this balance is locked in the
             // off chain wallet.
@@ -149,7 +155,7 @@ impl Wallet {
                 untrusted_pending: bdk_balance.untrusted_pending,
                 confirmed: bdk_balance.confirmed,
             },
-            off_chain: ldk_balance,
+            off_chain,
         })
     }
 
@@ -163,14 +169,63 @@ impl Wallet {
         Ok(balance)
     }
 
-    /// LDK balance is the total sum of money in all open channels
-    fn get_ldk_balance(&self) -> u64 {
-        self.lightning
+    /// The LDK [`OffChain`] balance keeps track of:
+    ///
+    /// - The total sum of money in all open channels.
+    /// - The total sum of money in close transactions that do not yet pay to our on-chain wallet.
+    fn get_ldk_balance(&self) -> Result<OffChain> {
+        let open_channels = self.lightning.channel_manager.list_channels();
+
+        let claimable_channel_balances = {
+            let ignored_channels = open_channels.iter().collect::<Vec<_>>();
+            let ignored_channels = &ignored_channels.as_slice();
+            self.lightning
+                .chain_monitor
+                .get_claimable_balances(ignored_channels)
+        };
+
+        let pending_close = claimable_channel_balances.iter().fold(0, |acc, balance| {
+            tracing::trace!("Pending on-chain balance from channel closure: {balance:?}");
+
+            use ::lightning::chain::channelmonitor::Balance::*;
+            match balance {
+                ClaimableOnChannelClose {
+                    claimable_amount_satoshis,
+                }
+                | ClaimableAwaitingConfirmations {
+                    claimable_amount_satoshis,
+                    ..
+                }
+                | ContentiousClaimable {
+                    claimable_amount_satoshis,
+                    ..
+                }
+                | MaybeTimeoutClaimableHTLC {
+                    claimable_amount_satoshis,
+                    ..
+                }
+                | MaybePreimageClaimableHTLC {
+                    claimable_amount_satoshis,
+                    ..
+                }
+                | CounterpartyRevokedOutputClaimable {
+                    claimable_amount_satoshis,
+                } => acc + claimable_amount_satoshis,
+            }
+        });
+
+        let available = self
+            .lightning
             .channel_manager
             .list_channels()
             .iter()
             .map(|details| details.balance_msat / 1000)
-            .sum()
+            .sum();
+
+        Ok(OffChain {
+            available,
+            pending_close,
+        })
     }
 
     fn get_channel_manager(&self) -> Arc<ChannelManager> {