diff --git a/bindings/ldk_node.udl b/bindings/ldk_node.udl index c6ffa168d..1e4526347 100644 --- a/bindings/ldk_node.udl +++ b/bindings/ldk_node.udl @@ -7,6 +7,7 @@ dictionary Config { string storage_dir_path; Network network; sequence? listening_addresses; + sequence? announcement_addresses; NodeAlias? node_alias; sequence trusted_peers_0conf; u64 probing_liquidity_limit_multiplier; @@ -84,6 +85,8 @@ interface Builder { [Throws=BuildError] void set_listening_addresses(sequence listening_addresses); [Throws=BuildError] + void set_announcement_addresses(sequence announcement_addresses); + [Throws=BuildError] void set_node_alias(string node_alias); [Throws=BuildError] Node build(); @@ -112,6 +115,7 @@ interface Node { void event_handled(); PublicKey node_id(); sequence? listening_addresses(); + sequence? announcement_addresses(); NodeAlias? node_alias(); Bolt11Payment bolt11_payment(); Bolt12Payment bolt12_payment(); @@ -319,6 +323,7 @@ enum BuildError { "InvalidSystemTime", "InvalidChannelMonitor", "InvalidListeningAddresses", + "InvalidAnnouncementAddresses", "InvalidNodeAlias", "ReadFailed", "WriteFailed", diff --git a/src/builder.rs b/src/builder.rs index b1f222770..7881f38e2 100644 --- a/src/builder.rs +++ b/src/builder.rs @@ -7,8 +7,8 @@ use crate::chain::{ChainSource, DEFAULT_ESPLORA_SERVER_URL}; use crate::config::{ - default_user_config, Config, EsploraSyncConfig, DEFAULT_LOG_FILENAME, DEFAULT_LOG_LEVEL, - WALLET_KEYS_SEED_LEN, + default_user_config, may_announce_channel, AnnounceError, Config, EsploraSyncConfig, + DEFAULT_LOG_FILENAME, DEFAULT_LOG_LEVEL, WALLET_KEYS_SEED_LEN, }; use crate::connection::ConnectionManager; @@ -32,8 +32,7 @@ use crate::types::{ }; use crate::wallet::persist::KVStoreWalletPersister; use crate::wallet::Wallet; -use crate::Node; -use crate::{io, NodeMetrics}; +use crate::{io, Node, NodeMetrics}; use lightning::chain::{chainmonitor, BestBlock, Watch}; use lightning::io::Cursor; @@ -148,6 +147,8 @@ pub enum BuildError { InvalidChannelMonitor, /// The given listening addresses are invalid, e.g. too many were passed. InvalidListeningAddresses, + /// The given announcement addresses are invalid, e.g. too many were passed. + InvalidAnnouncementAddresses, /// The provided alias is invalid. InvalidNodeAlias, /// We failed to read data from the [`KVStore`]. @@ -184,6 +185,9 @@ impl fmt::Display for BuildError { write!(f, "Failed to watch a deserialized ChannelMonitor") }, Self::InvalidListeningAddresses => write!(f, "Given listening addresses are invalid."), + Self::InvalidAnnouncementAddresses => { + write!(f, "Given announcement addresses are invalid.") + }, Self::ReadFailed => write!(f, "Failed to read from store."), Self::WriteFailed => write!(f, "Failed to write to store."), Self::StoragePathAccessFailed => write!(f, "Failed to access the given storage path."), @@ -413,6 +417,22 @@ impl NodeBuilder { Ok(self) } + /// Sets the IP address and TCP port which [`Node`] will announce to the gossip network that it accepts connections on. + /// + /// **Note**: If unset, the [`listening_addresses`] will be used as the list of addresses to announce. + /// + /// [`listening_addresses`]: Self::set_listening_addresses + pub fn set_announcement_addresses( + &mut self, announcement_addresses: Vec, + ) -> Result<&mut Self, BuildError> { + if announcement_addresses.len() > 100 { + return Err(BuildError::InvalidAnnouncementAddresses); + } + + self.config.announcement_addresses = Some(announcement_addresses); + Ok(self) + } + /// Sets the node alias that will be used when broadcasting announcements to the gossip /// network. /// @@ -776,6 +796,17 @@ impl ArcedNodeBuilder { self.inner.write().unwrap().set_listening_addresses(listening_addresses).map(|_| ()) } + /// Sets the IP address and TCP port which [`Node`] will announce to the gossip network that it accepts connections on. + /// + /// **Note**: If unset, the [`listening_addresses`] will be used as the list of addresses to announce. + /// + /// [`listening_addresses`]: Self::set_listening_addresses + pub fn set_announcement_addresses( + &self, announcement_addresses: Vec, + ) -> Result<(), BuildError> { + self.inner.write().unwrap().set_announcement_addresses(announcement_addresses).map(|_| ()) + } + /// Sets the node alias that will be used when broadcasting announcements to the gossip /// network. /// @@ -880,6 +911,23 @@ fn build_with_store_internal( liquidity_source_config: Option<&LiquiditySourceConfig>, seed_bytes: [u8; 64], logger: Arc, kv_store: Arc, ) -> Result { + if let Err(err) = may_announce_channel(&config) { + if config.announcement_addresses.is_some() { + log_error!(logger, "Announcement addresses were set but some required configuration options for node announcement are missing: {}", err); + let build_error = if matches!(err, AnnounceError::MissingNodeAlias) { + BuildError::InvalidNodeAlias + } else { + BuildError::InvalidListeningAddresses + }; + return Err(build_error); + } + + if config.node_alias.is_some() { + log_error!(logger, "Node alias was set but some required configuration options for node announcement are missing: {}", err); + return Err(BuildError::InvalidListeningAddresses); + } + } + // Initialize the status fields. let is_listening = Arc::new(AtomicBool::new(false)); let node_metrics = match read_node_metrics(Arc::clone(&kv_store), Arc::clone(&logger)) { diff --git a/src/config.rs b/src/config.rs index f04ff6243..46b528488 100644 --- a/src/config.rs +++ b/src/config.rs @@ -19,6 +19,7 @@ use lightning::util::config::UserConfig; use bitcoin::secp256k1::PublicKey; use bitcoin::Network; +use std::fmt; use std::time::Duration; // Config defaults @@ -117,6 +118,12 @@ pub struct Config { /// **Note**: We will only allow opening and accepting public channels if the `node_alias` and the /// `listening_addresses` are set. pub listening_addresses: Option>, + /// The addresses which the node will announce to the gossip network that it accepts connections on. + /// + /// **Note**: If unset, the [`listening_addresses`] will be used as the list of addresses to announce. + /// + /// [`listening_addresses`]: Config::listening_addresses + pub announcement_addresses: Option>, /// The node alias that will be used when broadcasting announcements to the gossip network. /// /// The provided alias must be a valid UTF-8 string and no longer than 32 bytes in total. @@ -168,6 +175,7 @@ impl Default for Config { storage_dir_path: DEFAULT_STORAGE_DIR_PATH.to_string(), network: DEFAULT_NETWORK, listening_addresses: None, + announcement_addresses: None, trusted_peers_0conf: Vec::new(), probing_liquidity_limit_multiplier: DEFAULT_PROBING_LIQUIDITY_LIMIT_MULTIPLIER, anchor_channels_config: Some(AnchorChannelsConfig::default()), @@ -256,9 +264,37 @@ pub fn default_config() -> Config { Config::default() } -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()) +#[derive(Debug, PartialEq)] +pub(crate) enum AnnounceError { + MissingNodeAlias, + MissingListeningAddresses, + MissingAliasAndAddresses, +} + +impl fmt::Display for AnnounceError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + AnnounceError::MissingNodeAlias => write!(f, "Node alias is not configured"), + AnnounceError::MissingListeningAddresses => { + write!(f, "Listening addresses are not configured") + }, + AnnounceError::MissingAliasAndAddresses => { + write!(f, "Node alias and listening addresses are not configured") + }, + } + } +} + +pub(crate) fn may_announce_channel(config: &Config) -> Result<(), AnnounceError> { + let has_listening_addresses = + config.listening_addresses.as_ref().map_or(false, |addrs| !addrs.is_empty()); + + match (config.node_alias.is_some(), has_listening_addresses) { + (true, true) => Ok(()), + (true, false) => Err(AnnounceError::MissingListeningAddresses), + (false, true) => Err(AnnounceError::MissingNodeAlias), + (false, false) => Err(AnnounceError::MissingAliasAndAddresses), + } } pub(crate) fn default_user_config(config: &Config) -> UserConfig { @@ -273,7 +309,7 @@ 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(); - if !may_announce_channel(config) { + if may_announce_channel(config).is_err() { user_config.accept_forwards_to_priv_channels = false; user_config.channel_handshake_config.announce_for_forwarding = false; user_config.channel_handshake_limits.force_announced_channel_preference = true; @@ -461,6 +497,7 @@ mod tests { use std::str::FromStr; use super::may_announce_channel; + use super::AnnounceError; use super::Config; use super::NodeAlias; use super::SocketAddress; @@ -469,7 +506,10 @@ mod tests { fn node_announce_channel() { // Default configuration with node alias and listening addresses unset let mut node_config = Config::default(); - assert!(!may_announce_channel(&node_config)); + assert_eq!( + may_announce_channel(&node_config), + Err(AnnounceError::MissingAliasAndAddresses) + ); // Set node alias with listening addresses unset let alias_frm_str = |alias: &str| { @@ -478,11 +518,26 @@ mod tests { NodeAlias(bytes) }; node_config.node_alias = Some(alias_frm_str("LDK_Node")); - assert!(!may_announce_channel(&node_config)); + assert_eq!( + may_announce_channel(&node_config), + Err(AnnounceError::MissingListeningAddresses) + ); + + // Set announcement addresses with listening addresses unset + let announcement_address = SocketAddress::from_str("123.45.67.89:9735") + .expect("Socket address conversion failed."); + node_config.announcement_addresses = Some(vec![announcement_address]); + assert_eq!( + may_announce_channel(&node_config), + Err(AnnounceError::MissingListeningAddresses) + ); // Set node alias with an empty list of listening addresses node_config.listening_addresses = Some(vec![]); - assert!(!may_announce_channel(&node_config)); + assert_eq!( + may_announce_channel(&node_config), + Err(AnnounceError::MissingListeningAddresses) + ); // Set node alias with a non-empty list of listening addresses let socket_address = @@ -490,6 +545,6 @@ mod tests { if let Some(ref mut addresses) = node_config.listening_addresses { addresses.push(socket_address); } - assert!(may_announce_channel(&node_config)); + assert!(may_announce_channel(&node_config).is_ok()); } } diff --git a/src/event.rs b/src/event.rs index c0028d220..0de59b858 100644 --- a/src/event.rs +++ b/src/event.rs @@ -1077,23 +1077,21 @@ where is_announced, params: _, } => { - if is_announced && !may_announce_channel(&*self.config) { - log_error!( - self.logger, - "Rejecting inbound announced channel from peer {} as not all required details are set. Please ensure node alias and listening addresses have been configured.", - counterparty_node_id, - ); + if is_announced { + if let Err(err) = may_announce_channel(&*self.config) { + log_error!(self.logger, "Rejecting inbound announced channel from peer {} due to missing configuration: {}", counterparty_node_id, err); - self.channel_manager - .force_close_without_broadcasting_txn( - &temporary_channel_id, - &counterparty_node_id, - "Channel request rejected".to_string(), - ) - .unwrap_or_else(|e| { - log_error!(self.logger, "Failed to reject channel: {:?}", e) - }); - return Ok(()); + self.channel_manager + .force_close_without_broadcasting_txn( + &temporary_channel_id, + &counterparty_node_id, + "Channel request rejected".to_string(), + ) + .unwrap_or_else(|e| { + log_error!(self.logger, "Failed to reject channel: {:?}", e) + }); + return Ok(()); + } } let anchor_channel = channel_type.requires_anchors_zero_fee_htlc_tx(); diff --git a/src/lib.rs b/src/lib.rs index 4eb1afe03..a80db1e8c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -414,7 +414,7 @@ impl Node { let bcast_node_metrics = Arc::clone(&self.node_metrics); let mut stop_bcast = self.stop_sender.subscribe(); let node_alias = self.config.node_alias.clone(); - if may_announce_channel(&self.config) { + if may_announce_channel(&self.config).is_ok() { runtime.spawn(async move { // We check every 30 secs whether our last broadcast is NODE_ANN_BCAST_INTERVAL away. #[cfg(not(test))] @@ -457,8 +457,10 @@ impl Node { continue; } - let addresses = if let Some(addresses) = bcast_config.listening_addresses.clone() { - addresses + let addresses = if let Some(announcement_addresses) = bcast_config.announcement_addresses.clone() { + announcement_addresses + } else if let Some(listening_addresses) = bcast_config.listening_addresses.clone() { + listening_addresses } else { debug_assert!(false, "We checked whether the node may announce, so listening addresses should always be set"); continue; @@ -802,6 +804,14 @@ impl Node { self.config.listening_addresses.clone() } + /// Returns the addresses that the node will announce to the network. + pub fn announcement_addresses(&self) -> Option> { + self.config + .announcement_addresses + .clone() + .or_else(|| self.config.listening_addresses.clone()) + } + /// Returns our node alias. pub fn node_alias(&self) -> Option { self.config.node_alias @@ -1201,19 +1211,19 @@ impl Node { &self, node_id: PublicKey, address: SocketAddress, channel_amount_sats: u64, push_to_counterparty_msat: Option, channel_config: Option, ) -> Result { - if may_announce_channel(&self.config) { - self.open_channel_inner( - node_id, - address, - channel_amount_sats, - push_to_counterparty_msat, - channel_config, - true, - ) - } 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"); + if let Err(err) = may_announce_channel(&self.config) { + log_error!(self.logger, "Failed to open announced channel as the node hasn't been sufficiently configured to act as a forwarding node: {}", err); return Err(Error::ChannelCreationFailed); } + + self.open_channel_inner( + node_id, + address, + channel_amount_sats, + push_to_counterparty_msat, + channel_config, + true, + ) } /// Manually sync the LDK and BDK wallets with the current chain state and update the fee rate diff --git a/tests/integration_tests_rust.rs b/tests/integration_tests_rust.rs index dd5820650..a41bca25c 100644 --- a/tests/integration_tests_rust.rs +++ b/tests/integration_tests_rust.rs @@ -11,8 +11,9 @@ use common::{ do_channel_full_cycle, expect_channel_pending_event, expect_channel_ready_event, expect_event, expect_payment_received_event, expect_payment_successful_event, generate_blocks_and_wait, logging::{init_log_logger, validate_log_entry, TestLogWriter}, - open_channel, premine_and_distribute_funds, random_config, setup_bitcoind_and_electrsd, - setup_builder, setup_node, setup_two_nodes, wait_for_tx, TestChainSource, TestSyncStore, + open_channel, premine_and_distribute_funds, random_config, random_listening_addresses, + setup_bitcoind_and_electrsd, setup_builder, setup_node, setup_two_nodes, wait_for_tx, + TestChainSource, TestSyncStore, }; use ldk_node::config::EsploraSyncConfig; @@ -24,6 +25,7 @@ use ldk_node::payment::{ use ldk_node::{Builder, Event, NodeError}; use lightning::ln::channelmanager::PaymentId; +use lightning::routing::gossip::{NodeAlias, NodeId}; use lightning::util::persist::KVStore; use bitcoincore_rpc::RpcApi; @@ -885,6 +887,97 @@ fn simple_bolt12_send_receive() { assert_eq!(node_a_payments.first().unwrap().amount_msat, Some(overpaid_amount)); } +#[test] +fn test_node_announcement_propagation() { + let (bitcoind, electrsd) = setup_bitcoind_and_electrsd(); + let chain_source = TestChainSource::Esplora(&electrsd); + + // Node A will use both listening and announcement addresses + let mut config_a = random_config(true); + let node_a_alias_string = "ldk-node-a".to_string(); + let mut node_a_alias_bytes = [0u8; 32]; + node_a_alias_bytes[..node_a_alias_string.as_bytes().len()] + .copy_from_slice(node_a_alias_string.as_bytes()); + let node_a_node_alias = Some(NodeAlias(node_a_alias_bytes)); + let node_a_announcement_addresses = random_listening_addresses(); + config_a.node_config.node_alias = node_a_node_alias.clone(); + config_a.node_config.listening_addresses = Some(random_listening_addresses()); + config_a.node_config.announcement_addresses = Some(node_a_announcement_addresses.clone()); + + // Node B will only use listening addresses + let mut config_b = random_config(true); + let node_b_alias_string = "ldk-node-b".to_string(); + let mut node_b_alias_bytes = [0u8; 32]; + node_b_alias_bytes[..node_b_alias_string.as_bytes().len()] + .copy_from_slice(node_b_alias_string.as_bytes()); + let node_b_node_alias = Some(NodeAlias(node_b_alias_bytes)); + let node_b_listening_addresses = random_listening_addresses(); + config_b.node_config.node_alias = node_b_node_alias.clone(); + config_b.node_config.listening_addresses = Some(node_b_listening_addresses.clone()); + config_b.node_config.announcement_addresses = None; + + let node_a = setup_node(&chain_source, config_a, None); + let node_b = setup_node(&chain_source, config_b, None); + + let address_a = node_a.onchain_payment().new_address().unwrap(); + let premine_amount_sat = 5_000_000; + premine_and_distribute_funds( + &bitcoind.client, + &electrsd.client, + vec![address_a], + Amount::from_sat(premine_amount_sat), + ); + + node_a.sync_wallets().unwrap(); + + // Open an announced channel from node_a to node_b + open_channel(&node_a, &node_b, 4_000_000, true, &electrsd); + + generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6); + + node_a.sync_wallets().unwrap(); + node_b.sync_wallets().unwrap(); + + expect_channel_ready_event!(node_a, node_b.node_id()); + expect_channel_ready_event!(node_b, node_a.node_id()); + + // Wait until node_b broadcasts a node announcement + while node_b.status().latest_node_announcement_broadcast_timestamp.is_none() { + std::thread::sleep(std::time::Duration::from_millis(10)); + } + + // Sleep to make sure the node announcement propagates + std::thread::sleep(std::time::Duration::from_secs(1)); + + // Get node info from the other node's perspective + let node_a_info = node_b.network_graph().node(&NodeId::from_pubkey(&node_a.node_id())).unwrap(); + let node_a_announcement_info = node_a_info.announcement_info.as_ref().unwrap(); + + let node_b_info = node_a.network_graph().node(&NodeId::from_pubkey(&node_b.node_id())).unwrap(); + let node_b_announcement_info = node_b_info.announcement_info.as_ref().unwrap(); + + // Assert that the aliases and addresses match the expected values + #[cfg(not(feature = "uniffi"))] + assert_eq!(node_a_announcement_info.alias(), &node_a_node_alias.unwrap()); + #[cfg(feature = "uniffi")] + assert_eq!(node_a_announcement_info.alias, node_a_alias_string); + + #[cfg(not(feature = "uniffi"))] + assert_eq!(node_a_announcement_info.addresses(), &node_a_announcement_addresses); + #[cfg(feature = "uniffi")] + assert_eq!(node_a_announcement_info.addresses, node_a_announcement_addresses); + + #[cfg(not(feature = "uniffi"))] + assert_eq!(node_b_announcement_info.alias(), &node_b_node_alias.unwrap()); + #[cfg(feature = "uniffi")] + assert_eq!(node_b_announcement_info.alias, node_b_alias_string); + + #[cfg(not(feature = "uniffi"))] + assert_eq!(node_b_announcement_info.addresses(), &node_b_listening_addresses); + #[cfg(feature = "uniffi")] + assert_eq!(node_b_announcement_info.addresses, node_b_listening_addresses); +} + #[test] fn generate_bip21_uri() { let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();