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

This reverts commit 4fd1cb8 as unit
tests need to be kept deterministic, i.e., opening announced channels is
a deliberate choice on a per test case basis.

Author: tnull

src/lib.rs

@@ -654,7 +654,6 @@ 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,36 +204,24 @@ 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 => false,
-		_ => true,
+		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))
+		},
 	}
 }
 
-pub(crate) fn random_config(anchor_channels: bool, announce_channel: bool) -> Config {
+pub(crate) fn random_config(anchor_channels: 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;
@@ -247,6 +235,10 @@ pub(crate) fn random_config(anchor_channels: bool, announce_channel: bool) -> Co
 	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
@@ -269,15 +261,14 @@ 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, announce_channel: bool,
+	electrsd: &ElectrsD, allow_0conf: bool, anchor_channels: bool, anchors_trusted_no_reserve: bool,
 ) -> (TestNode, TestNode) {
 	println!("== Node A ==");
-	let config_a = random_config(anchor_channels, announce_channel);
+	let config_a = random_config(anchor_channels);
 	let node_a = setup_node(electrsd, config_a);
 
 	println!("\n== Node B ==");
-	let mut config_b = random_config(anchor_channels, announce_channel);
+	let mut config_b = random_config(anchor_channels);
 	if allow_0conf {
 		config_b.trusted_peers_0conf.push(node_a.node_id());
 	}
@@ -415,28 +406,15 @@ 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,
 ) {
-	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();
-	}
-
+	node_a
+		.open_announced_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());
@@ -472,28 +450,15 @@ 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
-
-	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();
-	}
+	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,7 +9,6 @@
 
 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;
@@ -44,7 +43,7 @@ fn test_cln() {
 	common::generate_blocks_and_wait(&bitcoind_client, &electrs_client, 1);
 
 	// Setup LDK Node
-	let config = common::random_config(true, random_announce_channel());
+	let config = common::random_config(true);
 	let mut builder = Builder::from_config(config);
 	builder.set_esplora_server("http://127.0.0.1:3002".to_string());
 
@@ -83,19 +82,8 @@ fn test_cln() {
 	// Open the channel
 	let funding_amount_sat = 1_000_000;
 
-	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,
-		)
+	node.open_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);