Test peer persistance for inbound channel

Author: jbesraa

src/event.rs

@@ -1,8 +1,8 @@
 use crate::peer_store::{PeerInfo, PeerStore};
 use crate::types::PeerManager;
 use crate::{
-	hex_utils, ChannelManager, Config, Error, KeysManager, NetworkGraph, UserChannelId, Wallet,
-	FilesystemLogger
+	hex_utils, ChannelManager, Config, Error, FilesystemLogger, KeysManager, NetworkGraph,
+	UserChannelId, Wallet,
 };
 
 use crate::payment_store::{
@@ -267,8 +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>>>,
+		peer_manager: Arc<PeerManager<K>>, peer_store: Arc<PeerStore<K, Arc<FilesystemLogger>>>,
 	) -> Self {
 		Self {
 			event_queue,
@@ -281,7 +280,7 @@ where
 			runtime,
 			config,
 			peer_manager,
-			peer_store
+			peer_store,
 		}
 	}
 
@@ -650,24 +649,35 @@ where
 							if allow_0conf { " trusted" } else { "" },
 							counterparty_node_id,
 						);
-						// Persist channel
 						let peer_node_ids = self.peer_manager.get_peer_node_ids();
-						if let Some(peer) = peer_node_ids.iter().find(|(node_id, _)| node_id == &counterparty_node_id) {
+						if let Some(peer) = peer_node_ids
+							.iter()
+							.find(|(node_id, _)| node_id == &counterparty_node_id)
+						{
 							let address = match peer.1.clone() {
 								Some(address) => address,
 								None => {
-									log_error!(self.logger, "Failed to add peer to peer store: no network address found");
+									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.into() };
-							if let Err(e) = self.peer_store.add_peer(peer) {
-									log_error!(self.logger, "Failed to add peer to peer store: {}", e);
+							let peer =
+								PeerInfo { node_id: counterparty_node_id, address: address.into() };
+							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
+								),
 							};
-							log_info!(
-								self.logger,
-								"Persisted inbound channel from peer {}", counterparty_node_id
-							);
 						}
 					}
 					Err(e) => {

src/lib.rs

@@ -575,13 +575,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_debug!(connect_logger, "Reconnected to peer {}", node_id);
+													}
+													Err(e) => {
+														log_error!(connect_logger, "Failed to reconnect to peer {}: {}", node_id, e);
+													}
+												}
 										}
 									}
 						}

src/test/functional_tests.rs

@@ -11,6 +11,44 @@ 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();
+	println!("== Node A ==");
+	let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap());
+	let config_a = random_config();
+	let mut builder_a = NodeBuilder::from_config(config_a);
+	builder_a.set_esplora_server(esplora_url.clone());
+	let node_a = builder_a.build().unwrap();
+	node_a.start().unwrap();
+
+	println!("\n== Node B ==");
+	let mut config_b = random_config();
+	config_b.trusted_peers_0conf = vec![node_a.node_id()];
+	let mut builder_b = NodeBuilder::from_config(config_b.clone());
+	builder_b.set_esplora_server(esplora_url.clone());
+	let node_b = builder_b.build().unwrap();
+	node_b.start().unwrap();
+	open_channel(&node_a, &node_b, &bitcoind, &electrsd, true);
+	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).unwrap();
+	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();
@@ -48,6 +86,90 @@ fn channel_full_cycle_0conf() {
 	do_channel_full_cycle(node_a, node_b, &bitcoind, &electrsd, true)
 }
 
+fn open_channel<K: KVStore + Sync + Send>(
+	node_a: &Node<K>, node_b: &Node<K>, bitcoind: &BitcoinD, electrsd: &ElectrsD, allow_0conf: bool,
+) {
+	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);
+
+	// Check we haven't got any events yet
+	assert_eq!(node_a.next_event(), None);
+	assert_eq!(node_b.next_event(), None);
+
+	println!("\nA -- connect_open_channel -> B");
+	let funding_amount_sat = 80_000;
+	let push_msat = (funding_amount_sat / 2) * 1000; // balance the channel
+	node_a
+		.connect_open_channel(
+			node_b.node_id(),
+			node_b.listening_address().unwrap().into(),
+			funding_amount_sat,
+			Some(push_msat),
+			None,
+			true,
+		)
+		.unwrap();
+
+	assert_eq!(node_a.list_peers().first().unwrap().node_id, node_b.node_id());
+	expect_event!(node_a, ChannelPending);
+
+	let funding_txo = match node_b.wait_next_event() {
+		ref e @ Event::ChannelPending { funding_txo, .. } => {
+			println!("{} got event {:?}", std::stringify!(node_b), e);
+			assert_eq!(node_b.next_event().as_ref(), Some(e));
+			node_b.event_handled();
+			funding_txo
+		}
+		ref e => {
+			panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e);
+		}
+	};
+
+	wait_for_tx(&electrsd, funding_txo.txid);
+
+	if !allow_0conf {
+		println!("\n .. generating blocks ..");
+		generate_blocks_and_wait(&bitcoind, &electrsd, 6);
+	}
+
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+
+	let onchain_fee_buffer_sat = 1500;
+	let node_a_upper_bound_sat = premine_amount_sat - funding_amount_sat;
+	let node_a_lower_bound_sat = premine_amount_sat - funding_amount_sat - onchain_fee_buffer_sat;
+	assert!(node_a.spendable_onchain_balance_sats().unwrap() < node_a_upper_bound_sat);
+	assert!(node_a.spendable_onchain_balance_sats().unwrap() > node_a_lower_bound_sat);
+	assert_eq!(node_b.spendable_onchain_balance_sats().unwrap(), premine_amount_sat);
+
+	expect_event!(node_a, ChannelReady);
+
+	let ev = node_b.wait_next_event();
+	let _channel_id = match ev {
+		ref e @ Event::ChannelReady { ref channel_id, .. } => {
+			println!("{} got event {:?}", std::stringify!(node_b), e);
+			node_b.event_handled();
+			channel_id
+		}
+		ref e => {
+			panic!("{} got unexpected event!: {:?}", std::stringify!(node_b), e);
+		}
+	};
+}
+
 fn do_channel_full_cycle<K: KVStore + Sync + Send>(
 	node_a: Node<K>, node_b: Node<K>, bitcoind: &BitcoinD, electrsd: &ElectrsD, allow_0conf: bool,
 ) {