Replace ChannelAnnouncementStatus boilerplate with a simple bool flag

We drop the previously-introduced
`ChannelAnnouncementStatus`/`ChannelAnnouncementBlocker` types. While
informative, they were a bit too much boilerplate. Instead we opt to
simply return a `bool` from `may_announce_channel`, and don't spawn the
node announcment task to begin with if we're not configured properly.

Author: tnull

src/config.rs

@@ -278,47 +278,9 @@ pub fn default_config() -> Config {
 	Config::default()
 }
 
-/// Specifies reasons why a channel cannot be announced.
-#[derive(Debug, PartialEq)]
-pub(crate) enum ChannelAnnouncementBlocker {
-	/// The node alias is not set.
-	MissingNodeAlias,
-	/// The listening addresses are not set.
-	MissingListeningAddresses,
-	// This listening addresses is set but the vector is empty.
-	EmptyListeningAddresses,
-}
-
-/// Enumeration defining the announcement status of a channel.
-#[derive(Debug, PartialEq)]
-pub(crate) enum ChannelAnnouncementStatus {
-	/// The channel is announceable.
-	Announceable,
-	/// The channel is not announceable.
-	Unannounceable(ChannelAnnouncementBlocker),
-}
-
-/// Checks if a node is can announce a channel based on the configured values of both the node's
-/// alias and its listening addresses.
-///
-/// If either of them is unset, the node cannot announce the channel. This ability to announce/
-/// unannounce a channel is codified with `ChannelAnnouncementStatus`
-pub(crate) fn can_announce_channel(config: &Config) -> ChannelAnnouncementStatus {
-	if config.node_alias.is_none() {
-		return ChannelAnnouncementStatus::Unannounceable(
-			ChannelAnnouncementBlocker::MissingNodeAlias,
-		);
-	}
-
-	match &config.listening_addresses {
-		None => ChannelAnnouncementStatus::Unannounceable(
-			ChannelAnnouncementBlocker::MissingListeningAddresses,
-		),
-		Some(addresses) if addresses.is_empty() => ChannelAnnouncementStatus::Unannounceable(
-			ChannelAnnouncementBlocker::EmptyListeningAddresses,
-		),
-		Some(_) => ChannelAnnouncementStatus::Announceable,
-	}
+pub(crate) fn may_announce_channel(config: &Config) -> bool {
+	config.node_alias.is_some()
+		&& config.listening_addresses.as_ref().map_or(false, |addrs| !addrs.is_empty())
 }
 
 pub(crate) fn default_user_config(config: &Config) -> UserConfig {
@@ -333,13 +295,10 @@ pub(crate) fn default_user_config(config: &Config) -> UserConfig {
 	user_config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx =
 		config.anchor_channels_config.is_some();
 
-	match can_announce_channel(config) {
-		ChannelAnnouncementStatus::Announceable => (),
-		ChannelAnnouncementStatus::Unannounceable(_) => {
-			user_config.accept_forwards_to_priv_channels = false;
-			user_config.channel_handshake_config.announced_channel = false;
-			user_config.channel_handshake_limits.force_announced_channel_preference = true;
-		},
+	if !may_announce_channel(config) {
+		user_config.accept_forwards_to_priv_channels = false;
+		user_config.channel_handshake_config.announced_channel = false;
+		user_config.channel_handshake_limits.force_announced_channel_preference = true;
 	}
 
 	user_config
@@ -349,23 +308,16 @@ pub(crate) fn default_user_config(config: &Config) -> UserConfig {
 mod tests {
 	use std::str::FromStr;
 
-	use crate::config::ChannelAnnouncementStatus;
-
-	use super::can_announce_channel;
+	use super::may_announce_channel;
 	use super::Config;
 	use super::NodeAlias;
 	use super::SocketAddress;
 
 	#[test]
-	fn node_can_announce_channel() {
+	fn node_announce_channel() {
 		// Default configuration with node alias and listening addresses unset
 		let mut node_config = Config::default();
-		assert_eq!(
-			can_announce_channel(&node_config),
-			ChannelAnnouncementStatus::Unannounceable(
-				crate::config::ChannelAnnouncementBlocker::MissingNodeAlias
-			)
-		);
+		assert!(!may_announce_channel(&node_config));
 
 		// Set node alias with listening addresses unset
 		let alias_frm_str = |alias: &str| {
@@ -374,28 +326,18 @@ mod tests {
 			NodeAlias(bytes)
 		};
 		node_config.node_alias = Some(alias_frm_str("LDK_Node"));
-		assert_eq!(
-			can_announce_channel(&node_config),
-			ChannelAnnouncementStatus::Unannounceable(
-				crate::config::ChannelAnnouncementBlocker::MissingListeningAddresses
-			)
-		);
+		assert!(!may_announce_channel(&node_config));
 
 		// Set node alias with an empty list of listening addresses
 		node_config.listening_addresses = Some(vec![]);
-		assert_eq!(
-			can_announce_channel(&node_config),
-			ChannelAnnouncementStatus::Unannounceable(
-				crate::config::ChannelAnnouncementBlocker::EmptyListeningAddresses
-			)
-		);
+		assert!(!may_announce_channel(&node_config));
 
 		// Set node alias with a non-empty list of listening addresses
 		let socket_address =
 			SocketAddress::from_str("localhost:8000").expect("Socket address conversion failed.");
 		if let Some(ref mut addresses) = node_config.listening_addresses {
 			addresses.push(socket_address);
 		}
-		assert_eq!(can_announce_channel(&node_config), ChannelAnnouncementStatus::Announceable);
+		assert!(may_announce_channel(&node_config));
 	}
 }

src/lib.rs

@@ -122,8 +122,8 @@ pub use builder::BuildError;
 pub use builder::NodeBuilder as Builder;
 
 use config::{
-	can_announce_channel, default_user_config, ChannelAnnouncementStatus,
-	LDK_WALLET_SYNC_TIMEOUT_SECS, NODE_ANN_BCAST_INTERVAL, PEER_RECONNECTION_INTERVAL,
+	default_user_config, may_announce_channel, LDK_WALLET_SYNC_TIMEOUT_SECS,
+	NODE_ANN_BCAST_INTERVAL, PEER_RECONNECTION_INTERVAL,
 	RESOLVED_CHANNEL_MONITOR_ARCHIVAL_INTERVAL, RGS_SYNC_INTERVAL,
 	WALLET_SYNC_INTERVAL_MINIMUM_SECS,
 };
@@ -605,20 +605,20 @@ impl Node {
 		let bcast_ann_timestamp = Arc::clone(&self.latest_node_announcement_broadcast_timestamp);
 		let mut stop_bcast = self.stop_sender.subscribe();
 		let node_alias = self.config.node_alias.clone();
-		let can_announce_channel = can_announce_channel(&self.config);
-		runtime.spawn(async move {
-			// We check every 30 secs whether our last broadcast is NODE_ANN_BCAST_INTERVAL away.
-			#[cfg(not(test))]
-			let mut interval = tokio::time::interval(Duration::from_secs(30));
-			#[cfg(test)]
-			let mut interval = tokio::time::interval(Duration::from_secs(5));
-			loop {
-				tokio::select! {
+		if may_announce_channel(&self.config) {
+			runtime.spawn(async move {
+				// We check every 30 secs whether our last broadcast is NODE_ANN_BCAST_INTERVAL away.
+				#[cfg(not(test))]
+				let mut interval = tokio::time::interval(Duration::from_secs(30));
+				#[cfg(test)]
+				let mut interval = tokio::time::interval(Duration::from_secs(5));
+				loop {
+					tokio::select! {
 						_ = stop_bcast.changed() => {
 							log_trace!(
 								bcast_logger,
 								"Stopping broadcasting node announcements.",
-							);
+								);
 							return;
 						}
 						_ = interval.tick() => {
@@ -648,36 +648,37 @@ impl Node {
 								continue;
 							}
 
-							match can_announce_channel {
-								ChannelAnnouncementStatus::Unannounceable(_) => {
-									// Skip if we are not listening on any addresses or if the node alias is not set.
-									continue;
-								}
-								ChannelAnnouncementStatus::Announceable => {
-									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);
-									} else {
-										continue
-									}
-								}
-							}
+							let addresses = if let Some(addresses) = bcast_config.listening_addresses.clone() {
+								addresses
+							} else {
+								debug_assert!(false, "We checked whether the node may announce, so listening addresses should always be set");
+								continue;
+							};
+
+							if let Some(node_alias) = node_alias.as_ref() {
+								bcast_pm.broadcast_node_announcement([0; 3], node_alias.0, addresses);
 
-							let unix_time_secs_opt =
-								SystemTime::now().duration_since(UNIX_EPOCH).ok().map(|d| d.as_secs());
-							*bcast_ann_timestamp.write().unwrap() = unix_time_secs_opt;
+								let unix_time_secs_opt =
+									SystemTime::now().duration_since(UNIX_EPOCH).ok().map(|d| d.as_secs());
+								*bcast_ann_timestamp.write().unwrap() = unix_time_secs_opt;
 
-							if let Some(unix_time_secs) = unix_time_secs_opt {
-								io::utils::write_latest_node_ann_bcast_timestamp(unix_time_secs, Arc::clone(&bcast_store), Arc::clone(&bcast_logger))
-									.unwrap_or_else(|e| {
-										log_error!(bcast_logger, "Persistence failed: {}", e);
-										panic!("Persistence failed");
-									});
+								if let Some(unix_time_secs) = unix_time_secs_opt {
+									io::utils::write_latest_node_ann_bcast_timestamp(unix_time_secs, Arc::clone(&bcast_store), Arc::clone(&bcast_logger))
+										.unwrap_or_else(|e| {
+											log_error!(bcast_logger, "Persistence failed: {}", e);
+											panic!("Persistence failed");
+										});
+								}
+							} else {
+								debug_assert!(false, "We checked whether the node may announce, so node alias should always be set");
+								continue
 							}
+
 						}
+					}
 				}
-			}
-		});
+			});
+		}
 
 		let mut stop_tx_bcast = self.stop_sender.subscribe();
 		let tx_bcaster = Arc::clone(&self.tx_broadcaster);
@@ -1341,26 +1342,18 @@ impl Node {
 		&self, node_id: PublicKey, address: SocketAddress, channel_amount_sats: u64,
 		push_to_counterparty_msat: Option<u64>, channel_config: Option<ChannelConfig>,
 	) -> Result<UserChannelId, Error> {
-		match can_announce_channel(&self.config) {
-			config::ChannelAnnouncementStatus::Announceable => self.open_channel_inner(
+		if may_announce_channel(&self.config) {
+			self.open_channel_inner(
 				node_id,
 				address,
 				channel_amount_sats,
 				push_to_counterparty_msat,
 				channel_config,
 				true,
-			),
-			config::ChannelAnnouncementStatus::Unannounceable(reason) => match reason {
-				config::ChannelAnnouncementBlocker::MissingNodeAlias => {
-					return Err(Error::InvalidNodeAlias)
-				},
-				config::ChannelAnnouncementBlocker::MissingListeningAddresses => {
-					return Err(Error::InvalidSocketAddress)
-				},
-				config::ChannelAnnouncementBlocker::EmptyListeningAddresses => {
-					return Err(Error::InvalidSocketAddress)
-				},
-			},
+			)
+		} else {
+			log_error!(self.logger, "Failed to open announced channel as the node hasn't been sufficiently configured to act as a forwarding node. Please make sure to configure listening addreesses and node alias");
+			return Err(Error::ChannelCreationFailed);
 		}
 	}