add peer discovery

Author: randomlogin

sim-cli/src/parsing.rs

@@ -20,6 +20,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 use tokio_util::task::TaskTracker;
+use triggered::Listener;
 
 /// The default directory where the simulation files are stored and where the results will be written to.
 pub const DEFAULT_DATA_DIR: &str = ".";
@@ -359,8 +360,14 @@ pub async fn create_simulation(
         ldk_hub: _,
     } = sim_params;
 
-    let (clients, clients_info) = get_clients(nodes.to_vec(), sim_params.ldk_hub.clone()).await?;
     let (shutdown_trigger, shutdown_listener) = triggered::trigger();
+    let (clients, clients_info) = get_clients(
+        nodes.to_vec(),
+        sim_params.ldk_hub.clone(),
+        tasks.clone(),
+        shutdown_listener.clone(),
+    )
+    .await?;
 
     let validated_activities =
         get_validated_activities(&clients, clients_info, sim_params.activity.clone()).await?;
@@ -383,6 +390,8 @@ pub async fn create_simulation(
 async fn get_clients(
     nodes: Vec<NodeConnection>,
     ldk_hub: Option<ldk::LdkHubConfig>,
+    tasks: TaskTracker,
+    shutdown: Listener,
 ) -> Result<
     (
         HashMap<PublicKey, Arc<Mutex<dyn LightningNode>>>,
@@ -393,24 +402,12 @@ async fn get_clients(
     let mut clients: HashMap<PublicKey, Arc<Mutex<dyn LightningNode>>> = HashMap::new();
     let mut clients_info: HashMap<PublicKey, NodeInfo> = HashMap::new();
 
-    let (ldk_connections, other_connections): (Vec<_>, Vec<_>) =
-        nodes.into_iter().partition(|n| matches!(n, NodeConnection::Ldk(_)));
-
-    let ldk_configs: Vec<ldk::LdkNodeConfig> = ldk_connections
+    let (ldk_connections, other_connections): (Vec<_>, Vec<_>) = nodes
         .into_iter()
-        .filter_map(|n| match n {
-            NodeConnection::Ldk(cfg) => Some(cfg),
-            _ => None,
-        })
-        .collect();
-
-    for ldk_node in ldk::build_ldk_nodes(ldk_configs, ldk_hub).await? {
-        let info = ldk_node.get_info().clone();
-        let node: Arc<Mutex<dyn LightningNode>> = Arc::new(Mutex::new(ldk_node));
-        clients.insert(info.pubkey, node);
-        clients_info.insert(info.pubkey, info);
-    }
+        .partition(|n| matches!(n, NodeConnection::Ldk(_)));
 
+    // Build non-LDK nodes first so we have their peer addresses before connecting LDK nodes.
+    let mut non_ldk_peers: Vec<(PublicKey, String)> = Vec::new();
     for connection in other_connections {
         let node: Arc<Mutex<dyn LightningNode>> = match connection {
             NodeConnection::Lnd(c) => Arc::new(Mutex::new(LndNode::new(c).await?)),
@@ -419,10 +416,55 @@ async fn get_clients(
             NodeConnection::Ldk(_) => unreachable!(),
         };
         let node_info = node.lock().await.get_info().clone();
+        if let Some(addr) = node_info.p2p_addr.clone() {
+            non_ldk_peers.push((node_info.pubkey, addr));
+        } else {
+            log::warn!(
+                "No p2p_addr for {}: LDK nodes will not connect to it as a peer.",
+                node_info.alias
+            );
+        }
         clients.insert(node_info.pubkey, node);
         clients_info.insert(node_info.pubkey, node_info);
     }
 
+    let ldk_configs: Vec<ldk::LdkNodeConfig> = ldk_connections
+        .into_iter()
+        .filter_map(|n| match n {
+            NodeConnection::Ldk(cfg) => Some(cfg),
+            _ => None,
+        })
+        .collect();
+
+    let ldk_nodes = ldk::build_ldk_nodes(ldk_configs, ldk_hub, tasks, shutdown).await?;
+
+    // Collect LDK peer info for all-to-all connections.
+    let ldk_peers: Vec<(PublicKey, String)> = ldk_nodes
+        .iter()
+        .filter_map(|n| {
+            let info = n.get_info();
+            info.p2p_addr.as_ref().map(|addr| (info.pubkey, addr.clone()))
+        })
+        .collect();
+
+    for ldk_node in ldk_nodes {
+        let info = ldk_node.get_info().clone();
+
+        // Connect to every other LDK node.
+        for (peer_pk, peer_addr) in &ldk_peers {
+            if peer_pk != &info.pubkey {
+                ldk_node.connect_peer(*peer_pk, peer_addr);
+            }
+        }
+        // Connect to non-LDK nodes.
+        for (peer_pk, peer_addr) in &non_ldk_peers {
+            ldk_node.connect_peer(*peer_pk, peer_addr);
+        }
+
+        clients.insert(info.pubkey, Arc::new(Mutex::new(ldk_node)));
+        clients_info.insert(info.pubkey, info);
+    }
+
     Ok((clients, clients_info))
 }
 

simln-lib/src/cln.rs

@@ -92,6 +92,10 @@ impl ClnNode {
             .map_err(|err| LightningError::GetInfoError(err.to_string()))?
             .into_inner();
 
+        let p2p_addr = info.binding.first().and_then(|b| {
+            b.address.as_deref().zip(b.port).map(|(host, port)| format!("{}:{}", host, port))
+        });
+
         let pubkey = PublicKey::from_slice(&info.id)
             .map_err(|err| LightningError::GetInfoError(err.to_string()))?;
         let mut alias = info.alias;
@@ -111,6 +115,7 @@ impl ClnNode {
                 pubkey,
                 features,
                 alias,
+                p2p_addr,
             },
             network,
         })
@@ -249,13 +254,18 @@ impl LightningNode for ClnNode {
 
         // We are filtering `list_nodes` to a single node, so we should get either an empty vector or one with a single element
         if let Some(node) = nodes.pop() {
+            let p2p_addr = node
+                .addresses
+                .first()
+                .and_then(|a| a.address.as_ref().map(|host| format!("{}:{}", host, a.port)));
             Ok(NodeInfo {
                 pubkey: *node_id,
                 alias: node.alias.unwrap_or(String::new()),
                 features: node
                     .features
                     .clone()
                     .map_or(NodeFeatures::empty(), NodeFeatures::from_be_bytes),
+                p2p_addr,
             })
         } else {
             Err(LightningError::GetNodeInfoError(
@@ -282,15 +292,22 @@ impl LightningNode for ClnNode {
         let mut nodes_by_pk: HashMap<PublicKey, NodeInfo> = HashMap::new();
 
         for node in nodes {
+            let pubkey =
+                PublicKey::from_slice(&node.nodeid).expect("Public Key not valid");
+            let p2p_addr = node
+                .addresses
+                .first()
+                .and_then(|a| a.address.as_ref().map(|host| format!("{}:{}", host, a.port)));
             nodes_by_pk.insert(
-                PublicKey::from_slice(&node.nodeid).expect("Public Key not valid"),
+                pubkey,
                 NodeInfo {
-                    pubkey: PublicKey::from_slice(&node.nodeid).expect("Public Key not valid"),
+                    pubkey,
                     alias: node.clone().alias.unwrap_or(String::new()),
                     features: node
                         .features
                         .clone()
                         .map_or(NodeFeatures::empty(), NodeFeatures::from_be_bytes),
+                    p2p_addr,
                 },
             );
         }

simln-lib/src/eclair.rs

@@ -110,12 +110,15 @@ impl EclairNode {
         .map_err(|err| LightningError::ValidationError(err.to_string()))?;
         let features = parse_json_to_node_features(&info.features);
 
+        let p2p_addr = info.public_addresses.into_iter().next();
+
         Ok(Self {
             client: Mutex::new(client),
             info: NodeInfo {
                 pubkey,
                 alias: info.alias,
                 features,
+                p2p_addr,
             },
             network,
         })
@@ -214,11 +217,13 @@ impl LightningNode for EclairNode {
             .await
             .map_err(|err| LightningError::GetNodeInfoError(err.to_string()))?;
         let features = parse_json_to_node_features(&node_info.announcement.features);
+        let p2p_addr = node_info.announcement.addresses.into_iter().next();
 
         Ok(NodeInfo {
             pubkey: *node_id,
             alias: node_info.announcement.alias,
             features,
+            p2p_addr,
         })
     }
 
@@ -255,12 +260,15 @@ impl LightningNode for EclairNode {
         let mut nodes_by_pk: HashMap<PublicKey, NodeInfo> = HashMap::new();
 
         for node in nodes {
+            let pubkey = PublicKey::from_str(&node.node_id).expect("Public Key not valid");
+            let p2p_addr = node.addresses.into_iter().next();
             nodes_by_pk.insert(
-                PublicKey::from_str(&node.node_id).expect("Public Key not valid"),
+                pubkey,
                 NodeInfo {
-                    pubkey: PublicKey::from_str(&node.node_id).expect("Public Key not valid"),
+                    pubkey,
                     alias: node.alias.clone(),
                     features: parse_json_to_node_features(&node.features),
+                    p2p_addr,
                 },
             );
         }
@@ -276,6 +284,8 @@ struct GetInfoResponse {
     alias: String,
     network: String,
     features: Value,
+    #[serde(rename = "publicAddresses", default)]
+    public_addresses: Vec<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -305,6 +315,8 @@ type PaymentInfoResponse = Vec<PaymentPart>;
 struct Announcement {
     alias: String,
     features: Value,
+    #[serde(default)]
+    addresses: Vec<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -318,6 +330,8 @@ struct NodeInGraph {
     node_id: String,
     alias: String,
     features: Value,
+    #[serde(default)]
+    addresses: Vec<String>,
 }
 
 type ChannelsResponse = Vec<Channel>;