From fa404d1a55c0c901e6a9a3aa3b8627afa0f7a51e Mon Sep 17 00:00:00 2001
From: jbesraa <jbesraa@gmail.com>
Date: Tue, 3 Oct 2023 18:14:01 +0300
Subject: [PATCH] Persist peer info from inbound channel requests

  When we get an inbound channel request, we dont persist the
  peer info who initiated the request.
  In this commit, we use `[LdkEvent::ChannelPending]`
  to track channels that are inbound and their counterparty
  node id is not persisted, and if so,
  we add their `PeerInfo` to `PeerStore`.
  Notice that in order to persist this kind of data,
  we need first to get the listening address of the counterparty
  node, which is not always available, in that case we dont persist
  the peer info.
---
 src/event.rs | 35 +++++++++++++++++++++++++++++++++++
 src/lib.rs   | 14 +++++++++++---
 2 files changed, 46 insertions(+), 3 deletions(-)

diff --git a/src/event.rs b/src/event.rs
index ce75d673e..ca92346d8 100644
--- a/src/event.rs
+++ b/src/event.rs
@@ -1,3 +1,4 @@
+use crate::peer_store::{PeerInfo, PeerStore};
 use crate::{
 	hex_utils, ChannelManager, Config, Error, KeysManager, NetworkGraph, UserChannelId, Wallet,
 };
@@ -251,6 +252,7 @@ where
 	runtime: Arc<RwLock<Option<tokio::runtime::Runtime>>>,
 	logger: L,
 	config: Arc<Config>,
+	peer_store: Arc<PeerStore<K, L>>,
 }
 
 impl<K: KVStore + Sync + Send + 'static, L: Deref> EventHandler<K, L>
@@ -262,6 +264,7 @@ where
 		channel_manager: Arc<ChannelManager<K>>, network_graph: Arc<NetworkGraph>,
 		keys_manager: Arc<KeysManager>, payment_store: Arc<PaymentStore<K, L>>,
 		runtime: Arc<RwLock<Option<tokio::runtime::Runtime>>>, logger: L, config: Arc<Config>,
+		peer_store: Arc<PeerStore<K, L>>,
 	) -> Self {
 		Self {
 			event_queue,
@@ -273,6 +276,7 @@ where
 			logger,
 			runtime,
 			config,
+			peer_store,
 		}
 	}
 
@@ -739,6 +743,37 @@ where
 						log_error!(self.logger, "Failed to push to event queue: {}", e);
 						panic!("Failed to push to event queue");
 					});
+				let network_graph = self.network_graph.read_only();
+				let channels =
+					self.channel_manager.list_channels_with_counterparty(&counterparty_node_id);
+				if let Some(pending_channel) =
+					channels.into_iter().find(|c| c.channel_id == channel_id)
+				{
+					if !pending_channel.is_outbound
+						&& self.peer_store.get_peer(&counterparty_node_id).is_none()
+					{
+						if let Some(address) = network_graph
+							.nodes()
+							.get(&NodeId::from_pubkey(&counterparty_node_id))
+							.and_then(|node_info| node_info.announcement_info.as_ref())
+							.and_then(|ann_info| ann_info.addresses().first())
+						{
+							let peer = PeerInfo {
+								node_id: counterparty_node_id,
+								address: address.clone(),
+							};
+
+							self.peer_store.add_peer(peer).unwrap_or_else(|e| {
+								log_error!(
+									self.logger,
+									"Failed to add peer {} to peer store: {}",
+									counterparty_node_id,
+									e
+								);
+							});
+						}
+					}
+				}
 			}
 			LdkEvent::ChannelReady {
 				channel_id, user_channel_id, counterparty_node_id, ..
diff --git a/src/lib.rs b/src/lib.rs
index cce7e4109..33574972b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -570,13 +570,20 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 									.filter(|id| !pm_peers.contains(id))
 									{
 										if let Some(peer_info) = connect_peer_store.get_peer(&node_id) {
-											let _ = do_connect_peer(
+											let res = do_connect_peer(
 												peer_info.node_id,
 												peer_info.address,
 												Arc::clone(&connect_pm),
 												Arc::clone(&connect_logger),
-												)
-												.await;
+												).await;
+											match res {
+												Ok(_) => {
+													log_info!(connect_logger, "Successfully reconnected to peer {}", node_id);
+												},
+												Err(e) => {
+													log_error!(connect_logger, "Failed to reconnect to peer {}: {}", node_id, e);
+												}
+											}
 										}
 									}
 						}
@@ -656,6 +663,7 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 			Arc::clone(&self.runtime),
 			Arc::clone(&self.logger),
 			Arc::clone(&self.config),
+			Arc::clone(&self.peer_store),
 		));
 
 		// Setup background processing