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.

Author: jbesraa

src/builder.rs

@@ -574,11 +574,7 @@ fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
 	let mut user_config = UserConfig::default();
 	user_config.channel_handshake_limits.force_announced_channel_preference = false;
 
-	if !config.trusted_peers_0conf.is_empty() {
-		// Manually accept inbound channels if we expect 0conf channel requests, avoid
-		// generating the events otherwise.
-		user_config.manually_accept_inbound_channels = true;
-	}
+	user_config.manually_accept_inbound_channels = true;
 	let channel_manager = {
 		if let Ok(res) = kv_store.read(
 			CHANNEL_MANAGER_PERSISTENCE_PRIMARY_NAMESPACE,

src/event.rs

@@ -1,5 +1,7 @@
+use crate::peer_store::{PeerInfo, PeerStore};
 use crate::{
-	hex_utils, ChannelManager, Config, Error, KeysManager, NetworkGraph, UserChannelId, Wallet,
+	hex_utils, ChannelManager, Config, Error, FilesystemLogger, KeysManager, NetworkGraph,
+	UserChannelId, Wallet,
 };
 
 use crate::payment_store::{
@@ -251,6 +253,7 @@ where
 	runtime: Arc<RwLock<Option<tokio::runtime::Runtime>>>,
 	logger: L,
 	config: Arc<Config>,
+	peer_store: Arc<PeerStore<K, Arc<FilesystemLogger>>>,
 }
 
 impl<K: KVStore + Sync + Send + 'static, L: Deref> EventHandler<K, L>
@@ -262,6 +265,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, Arc<FilesystemLogger>>>,
 	) -> Self {
 		Self {
 			event_queue,
@@ -273,6 +277,7 @@ where
 			logger,
 			runtime,
 			config,
+			peer_store,
 		}
 	}
 
@@ -739,6 +744,57 @@ 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()
+					{
+						let nodes = network_graph.nodes();
+						if let Some(node_info) =
+							nodes.get(&NodeId::from_pubkey(&counterparty_node_id))
+						{
+							let ann_info = match node_info.announcement_info.clone() {
+								Some(ann_info) => ann_info,
+								None => {
+									log_error!(self.logger,
+								"Failed to add peer {} to peer store: no network address found",
+								counterparty_node_id);
+									return;
+								}
+							};
+							let address =
+								match ann_info.addresses().first() {
+									Some(address) => address,
+									None => {
+										log_error!(self.logger, "Failed to add peer {} to peer store: no network address
+								found", counterparty_node_id);
+										return;
+									}
+								};
+							let peer = PeerInfo {
+								node_id: counterparty_node_id,
+								address: address.clone(),
+							};
+							match self.peer_store.add_peer(peer) {
+								Ok(_) => log_info!(
+									self.logger,
+									"Added peer {} to peer store",
+									counterparty_node_id
+								),
+								Err(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, ..

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(
+											match do_connect_peer(
 												peer_info.node_id,
 												peer_info.address,
 												Arc::clone(&connect_pm),
 												Arc::clone(&connect_logger),
 												)
-												.await;
+												.await {
+													Ok(_) => {
+														log_info!(connect_logger, "Successfully reconnected to peer {}", node_id);
+													}
+													Err(e) => {
+														log_error!(connect_logger, "Failed to connect to peer: {}", 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