Persist inbound channel coming through OpenChannelRequest

  - Add `peer_store` and `peer_manager` to `[EventHandler::new]`
    function
  - Persist channel peer info in `[LdkEvent::OpenChannelRequest]` event

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,8 @@
+use crate::peer_store::{PeerInfo, PeerStore};
+use crate::types::PeerManager;
 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 +254,8 @@ where
 	runtime: Arc<RwLock<Option<tokio::runtime::Runtime>>>,
 	logger: L,
 	config: Arc<Config>,
+	peer_manager: Arc<PeerManager<K>>,
+	peer_store: Arc<PeerStore<K, Arc<FilesystemLogger>>>,
 }
 
 impl<K: KVStore + Sync + Send + 'static, L: Deref> EventHandler<K, L>
@@ -262,6 +267,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_manager: Arc<PeerManager<K>>, peer_store: Arc<PeerStore<K, Arc<FilesystemLogger>>>,
 	) -> Self {
 		Self {
 			event_queue,
@@ -273,6 +279,8 @@ where
 			logger,
 			runtime,
 			config,
+			peer_manager,
+			peer_store,
 		}
 	}
 
@@ -641,6 +649,47 @@ where
 							if allow_0conf { " trusted" } else { "" },
 							counterparty_node_id,
 						);
+						let network_graph = self.network_graph.read_only();
+						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
+								),
+							};
+						}
 					}
 					Err(e) => {
 						log_error!(

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,8 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 			Arc::clone(&self.runtime),
 			Arc::clone(&self.logger),
 			Arc::clone(&self.config),
+			Arc::clone(&self.peer_manager),
+			Arc::clone(&self.peer_store),
 		));
 
 		// Setup background processing

src/test/functional_tests.rs

@@ -1,7 +1,10 @@
 use crate::builder::NodeBuilder;
 use crate::io::test_utils::TestSyncStore;
 use crate::test::utils::*;
-use crate::test::utils::{expect_channel_pending_event, expect_event, open_channel, random_config};
+use crate::test::utils::{
+	expect_channel_pending_event, expect_channel_ready_event, expect_event, open_channel,
+	random_config,
+};
 use crate::{Error, Event, Node, PaymentDirection, PaymentStatus};
 
 use bitcoin::Amount;
@@ -11,6 +14,53 @@ use lightning::util::persist::KVStore;
 
 use std::sync::Arc;
 
+#[test]
+fn persist_peer_from_inbound_channel() {
+	// Channel A open a channel to B,
+	// B should persist A as a peer by adding there
+	// node_id to peer_store
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let funding_amount_sat = 80_000;
+	let (node_a, node_b) = setup_two_nodes(&electrsd, false);
+	let addr_a = node_a.new_onchain_address().unwrap();
+	let addr_b = node_b.new_onchain_address().unwrap();
+
+	let premine_amount_sat = 100_000;
+
+	premine_and_distribute_funds(
+		&bitcoind,
+		&electrsd,
+		vec![addr_a, addr_b],
+		Amount::from_sat(premine_amount_sat),
+	);
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+	assert_eq!(node_a.spendable_onchain_balance_sats().unwrap(), premine_amount_sat);
+	assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), premine_amount_sat);
+	assert_eq!(node_a.next_event(), None);
+	assert_eq!(node_b.next_event(), None);
+	open_channel(&node_a, &node_b, funding_amount_sat, true, &electrsd);
+	generate_blocks_and_wait(&bitcoind, &electrsd, 6);
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+	expect_channel_ready_event!(&node_a, Some(node_b.node_id()));
+	expect_channel_ready_event!(&node_b, Some(node_a.node_id()));
+	let node_b_id = node_b.node_id();
+	let node_a_id = node_a.node_id();
+	node_b.stop().unwrap();
+	assert_eq!(node_b.stop(), Err(Error::NotRunning));
+	node_b.start().unwrap();
+	node_b.sync_wallets().unwrap();
+	assert_eq!(node_b.is_running(), true);
+	assert_eq!(node_b.node_id(), node_b_id);
+	assert_eq!(node_a.is_running(), true);
+	let node_b_peers = node_b.list_peers();
+	let node_b_peers = node_b_peers.get(0).expect("Should have one peer");
+	assert_eq!(node_b_peers.node_id, node_a_id);
+	assert_eq!(node_b_peers.is_persisted, true);
+	assert_eq!(node_b_peers.is_connected, true);
+}
+
 #[test]
 fn channel_full_cycle() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();

src/test/utils.rs

@@ -57,6 +57,24 @@ macro_rules! expect_channel_pending_event {
 
 pub(crate) use expect_channel_pending_event;
 
+macro_rules! expect_channel_ready_event {
+	($node: expr, $counterparty_node_id: expr) => {{
+		match $node.wait_next_event() {
+			ref e @ Event::ChannelReady { ref channel_id, counterparty_node_id, .. } => {
+				println!("{} got event {:?}", $node.node_id(), e);
+				assert_eq!(counterparty_node_id, $counterparty_node_id);
+				$node.event_handled();
+				channel_id
+			}
+			ref e => {
+				panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e);
+			}
+		}
+	}};
+}
+
+pub(crate) use expect_channel_ready_event;
+
 // Copied over from upstream LDK
 #[allow(dead_code)]
 pub struct TestLogger {