fix(test): Implement conditional channel opening based on aliases and addresses

This commit addresses flaky test issues related to conditional channel
opening between nodes, considering node aliases and listening addresses.

Changes in test modules:
- Add/modify helper functions to randomize channel announcement flags
- Generate random node aliases based on announcement flags:
  * Set custom alias if announce_channel is true
  * Use default alias otherwise
- Update channel opening logic to account for node and channel announcements

Author: enigbe

src/lib.rs

@@ -654,6 +654,7 @@ impl Node {
 									continue;
 								}
 								ChannelAnnouncementStatus::Announceable => {
+									// Broadcast node announcement.
 									let addresses = bcast_config.listening_addresses.clone().unwrap_or(Vec::new());
 									if let Some(node_alias) = node_alias.as_ref() {
 										bcast_pm.broadcast_node_announcement([0; 3], node_alias.0, addresses);

tests/common/mod.rs

@@ -204,24 +204,36 @@ pub(crate) fn random_listening_addresses() -> Vec<SocketAddress> {
 pub(crate) fn random_node_alias() -> Option<NodeAlias> {
 	let mut rng = thread_rng();
 	let ranged_val = rng.gen_range(0..10);
+
+	let alias = format!("ldk-node-{}", ranged_val);
+	let mut bytes = [0u8; 32];
+	bytes[..alias.as_bytes().len()].copy_from_slice(alias.as_bytes());
+
+	Some(NodeAlias(bytes))
+}
+
+pub(crate) fn random_announce_channel() -> bool {
+	let mut rng = thread_rng();
+	let ranged_val = rng.gen_range(0..=1);
 	match ranged_val {
-		0 => None,
-		val => {
-			let alias = format!("ldk-node-{}", val);
-			let mut bytes = [0u8; 32];
-			bytes[..alias.as_bytes().len()].copy_from_slice(alias.as_bytes());
-			Some(NodeAlias(bytes))
-		},
+		0 => false,
+		_ => true,
 	}
 }
 
-pub(crate) fn random_config(anchor_channels: bool) -> Config {
+pub(crate) fn random_config(anchor_channels: bool, announce_channel: bool) -> Config {
 	let mut config = Config::default();
 
 	if !anchor_channels {
 		config.anchor_channels_config = None;
 	}
 
+	if announce_channel {
+		let alias = random_node_alias();
+		println!("Setting random LDK node alias: {:?}", alias);
+		config.node_alias = alias;
+	}
+
 	config.network = Network::Regtest;
 	config.onchain_wallet_sync_interval_secs = 100000;
 	config.wallet_sync_interval_secs = 100000;
@@ -235,10 +247,6 @@ pub(crate) fn random_config(anchor_channels: bool) -> Config {
 	println!("Setting random LDK listening addresses: {:?}", rand_listening_addresses);
 	config.listening_addresses = Some(rand_listening_addresses);
 
-	let alias = random_node_alias();
-	println!("Setting random LDK node alias: {:?}", alias);
-	config.node_alias = alias;
-
 	config.log_level = LogLevel::Gossip;
 
 	config
@@ -261,14 +269,15 @@ macro_rules! setup_builder {
 pub(crate) use setup_builder;
 
 pub(crate) fn setup_two_nodes(
-	electrsd: &ElectrsD, allow_0conf: bool, anchor_channels: bool, anchors_trusted_no_reserve: bool,
+	electrsd: &ElectrsD, allow_0conf: bool, anchor_channels: bool,
+	anchors_trusted_no_reserve: bool, announce_channel: bool,
 ) -> (TestNode, TestNode) {
 	println!("== Node A ==");
-	let config_a = random_config(anchor_channels);
+	let config_a = random_config(anchor_channels, announce_channel);
 	let node_a = setup_node(electrsd, config_a);
 
 	println!("\n== Node B ==");
-	let mut config_b = random_config(anchor_channels);
+	let mut config_b = random_config(anchor_channels, announce_channel);
 	if allow_0conf {
 		config_b.trusted_peers_0conf.push(node_a.node_id());
 	}
@@ -406,15 +415,28 @@ pub(crate) fn premine_and_distribute_funds<E: ElectrumApi>(
 pub fn open_channel(
 	node_a: &TestNode, node_b: &TestNode, funding_amount_sat: u64, electrsd: &ElectrsD,
 ) {
-	node_a
-		.open_announced_channel(
-			node_b.node_id(),
-			node_b.listening_addresses().unwrap().first().unwrap().clone(),
-			funding_amount_sat,
-			None,
-			None,
-		)
-		.unwrap();
+	if node_a.config().node_alias.is_some() {
+		node_a
+			.open_announced_channel(
+				node_b.node_id(),
+				node_b.listening_addresses().unwrap().first().unwrap().clone(),
+				funding_amount_sat,
+				None,
+				None,
+			)
+			.unwrap();
+	} else {
+		node_a
+			.open_channel(
+				node_b.node_id(),
+				node_b.listening_addresses().unwrap().first().unwrap().clone(),
+				funding_amount_sat,
+				None,
+				None,
+			)
+			.unwrap();
+	}
+
 	assert!(node_a.list_peers().iter().find(|c| { c.node_id == node_b.node_id() }).is_some());
 
 	let funding_txo_a = expect_channel_pending_event!(node_a, node_b.node_id());
@@ -450,15 +472,28 @@ pub(crate) fn do_channel_full_cycle<E: ElectrumApi>(
 	println!("\nA -- open_channel -> B");
 	let funding_amount_sat = 2_080_000;
 	let push_msat = (funding_amount_sat / 2) * 1000; // balance the channel
-	node_a
-		.open_channel(
-			node_b.node_id(),
-			node_b.listening_addresses().unwrap().first().unwrap().clone(),
-			funding_amount_sat,
-			Some(push_msat),
-			None,
-		)
-		.unwrap();
+
+	if node_a.config().node_alias.is_some() {
+		node_a
+			.open_announced_channel(
+				node_b.node_id(),
+				node_b.listening_addresses().unwrap().first().unwrap().clone(),
+				funding_amount_sat,
+				Some(push_msat),
+				None,
+			)
+			.unwrap();
+	} else {
+		node_a
+			.open_channel(
+				node_b.node_id(),
+				node_b.listening_addresses().unwrap().first().unwrap().clone(),
+				funding_amount_sat,
+				Some(push_msat),
+				None,
+			)
+			.unwrap();
+	}
 
 	assert_eq!(node_a.list_peers().first().unwrap().node_id, node_b.node_id());
 	assert!(node_a.list_peers().first().unwrap().is_persisted);

tests/integration_tests_cln.rs

@@ -9,6 +9,7 @@
 
 mod common;
 
+use common::random_announce_channel;
 use ldk_node::bitcoin::secp256k1::PublicKey;
 use ldk_node::bitcoin::Amount;
 use ldk_node::lightning::ln::msgs::SocketAddress;
@@ -43,7 +44,7 @@ fn test_cln() {
 	common::generate_blocks_and_wait(&bitcoind_client, &electrs_client, 1);
 
 	// Setup LDK Node
-	let config = common::random_config(true);
+	let config = common::random_config(true, random_announce_channel());
 	let mut builder = Builder::from_config(config);
 	builder.set_esplora_server("http://127.0.0.1:3002".to_string());
 
@@ -82,8 +83,19 @@ fn test_cln() {
 	// Open the channel
 	let funding_amount_sat = 1_000_000;
 
-	node.open_channel(cln_node_id, cln_address, funding_amount_sat, Some(500_000_000), None)
+	if node.config().node_alias.is_none() {
+		node.open_channel(cln_node_id, cln_address, funding_amount_sat, Some(500_000_000), None)
+			.unwrap();
+	} else {
+		node.open_announced_channel(
+			cln_node_id,
+			cln_address,
+			funding_amount_sat,
+			Some(500_000_000),
+			None,
+		)
 		.unwrap();
+	}
 
 	let funding_txo = common::expect_channel_pending_event!(node, cln_node_id);
 	common::wait_for_tx(&electrs_client, funding_txo.txid);