Fix peer store management on channel closure

src/event.rs

@@ -1585,6 +1585,44 @@ where
 			} => {
 				log_info!(self.logger, "Channel {} closed due to: {}", channel_id, reason);
 
+				// If the counterparty initiated closure of their last remaining channel
+				// with us, remove them from the peer store so we stop trying to reconnect.
+				//
+				// If we initiated the closure, keep them in the peer store so the
+				// background reconnection task fires and we can complete the
+				// channel_reestablish recovery flow. This matters especially for LND
+				// peers, which need us to reconnect to recover from force-closures.
+				//
+				// We exclude `channel_id` from the remaining-channel check because LDK
+				// fires ChannelClosed before removing the channel from its internal list,
+				// so list_channels_with_counterparty still includes the closing channel.
+				if let Some(counterparty_node_id) = counterparty_node_id {
+					let counterparty_initiated = matches!(
+						reason,
+						ClosureReason::CounterpartyForceClosed { .. }
+							| ClosureReason::CounterpartyInitiatedCooperativeClosure
+					);
+
+					if counterparty_initiated {
+						let has_other_channels = self
+							.channel_manager
+							.list_channels_with_counterparty(&counterparty_node_id)
+							.iter()
+							.any(|c| c.channel_id != channel_id);
+
+						if !has_other_channels {
+							if let Err(e) = self.peer_store.remove_peer(&counterparty_node_id) {
+								log_error!(
+									self.logger,
+									"Failed to remove peer {} from peer store: {}",
+									counterparty_node_id,
+									e
+								);
+							}
+						}
+					}
+				}
+
 				let event = Event::ChannelClosed {
 					channel_id,
 					user_channel_id: UserChannelId(user_channel_id),

src/lib.rs

@@ -1841,8 +1841,16 @@ impl Node {
 					})?;
 			}
 
-			// Check if this was the last open channel, if so, forget the peer.
-			if open_channels.len() == 1 {
+			// If this was the last open channel and we're closing cooperatively, forget the peer
+			// since we have no further reason to reconnect.
+
+			// For force-closes we intentionally keep the peer in the store so the background reconnection
+			// task keeps firing and can drive the channel_reestablish recovery flow.
+			// This is especially important against LND peers, which don't always handle force-closure error messages correctly.
+
+			//Note that this means a force-closed peer is retained until the user explicitly calls Node::disconnect.
+
+			if open_channels.len() == 1 && !force {
 				self.peer_store.remove_peer(&counterparty_node_id)?;
 			}
 		}

tests/common/mod.rs

@@ -1545,6 +1545,20 @@ pub(crate) async fn do_channel_full_cycle<E: ElectrumApi>(
 		node_b.sync_wallets().unwrap();
 	}
 
+	if force_close {
+		// Peer retained after local force-close to allow channel_reestablish recovery.
+		assert!(
+			node_a.list_peers().iter().any(|p| p.node_id == node_b.node_id() && p.is_persisted),
+			"node_b should remain persisted in node_a peer store after locally-initiated force-close"
+		);
+	} else {
+		// Peer removed after cooperative close — no further reason to reconnect.
+		assert!(
+			!node_a.list_peers().iter().any(|p| p.node_id == node_b.node_id() && p.is_persisted),
+			"node_b should be removed from node_a peer store after cooperative close"
+		);
+	}
+
 	let sum_of_all_payments_sat = (push_msat
 		+ invoice_amount_1_msat
 		+ overpaid_amount_msat