Allow unspecified alias destinations

README.md

@@ -248,10 +248,7 @@ The example simulation file below sets up the following simulation:
 ```
 
 
-Nodes can be identified by their public key or an id string (as 
-described above). Activity sources and destinations may reference the 
-`id` defined in `nodes`, but destinations that are not listed in `nodes` 
-*must* provide a valid public key.
+Nodes can be identified by their public key or an id string (as described above). Activity sources and destinations may reference the `id` defined in `nodes`. However, if multiple destination nodes have the same id string (alias), valid public keys *must* be used to identify the nodes.
 
 ### Simulation Output
 

sim-cli/src/parsing.rs

@@ -5,12 +5,11 @@ use log::LevelFilter;
 use serde::{Deserialize, Serialize};
 use simln_lib::{
     cln, cln::ClnNode, eclair, eclair::EclairNode, lnd, lnd::LndNode, serializers,
-    ActivityDefinition, Amount, Interval, LightningError, LightningNode, NodeId, NodeInfo,
+    ActivityDefinition, Amount, Graph, Interval, LightningError, LightningNode, NodeId, NodeInfo,
     Simulation, SimulationCfg, WriteResults,
 };
 use std::collections::HashMap;
 use std::fs;
-use std::ops::AsyncFn;
 use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::sync::Mutex;
@@ -159,20 +158,15 @@ pub async fn create_simulation(cli: &Cli) -> Result<Simulation, anyhow::Error> {
     let (clients, clients_info) = get_clients(nodes).await?;
     // We need to be able to look up destination nodes in the graph, because we allow defined activities to send to
     // nodes that we do not control. To do this, we can just grab the first node in our map and perform the lookup.
-    let get_node = async |pk: &PublicKey| -> Result<NodeInfo, LightningError> {
-        if let Some(c) = clients.values().next() {
-            return c.lock().await.get_node_info(pk).await;
-        }
-
-        Err(LightningError::GetNodeInfoError(
-            "no nodes for query".to_string(),
-        ))
+    let graph = match clients.values().next() {
+        Some(client) => client.lock().await.get_graph().await?,
+        None => panic!("Graph is empty"),
     };
 
     let (pk_node_map, alias_node_map) = add_node_to_maps(&clients_info).await?;
 
     let validated_activities =
-        validate_activities(activity, pk_node_map, alias_node_map, get_node).await?;
+        validate_activities(activity, pk_node_map, alias_node_map, graph).await?;
     let tasks = TaskTracker::new();
 
     Ok(Simulation::new(cfg, clients, validated_activities, tasks))
@@ -215,9 +209,9 @@ async fn get_clients(
 /// validation.
 async fn add_node_to_maps(
     nodes: &HashMap<PublicKey, NodeInfo>,
-) -> Result<(HashMap<PublicKey, NodeInfo>, HashMap<String, NodeInfo>), LightningError> {
+) -> Result<(HashMap<PublicKey, NodeInfo>, HashMap<String, Vec<NodeInfo>>), LightningError> {
     let mut pk_node_map = HashMap::new();
-    let mut alias_node_map = HashMap::new();
+    let mut alias_node_map: HashMap<String, Vec<NodeInfo>> = HashMap::new();
 
     for node_info in nodes.values() {
         log::info!(
@@ -241,7 +235,7 @@ async fn add_node_to_maps(
                 )));
             }
 
-            alias_node_map.insert(node_info.alias.clone(), node_info.clone());
+            alias_node_map.insert(node_info.alias.clone(), vec![node_info.clone()]);
         }
 
         pk_node_map.insert(node_info.pubkey, node_info.clone());
@@ -255,31 +249,72 @@ async fn add_node_to_maps(
 async fn validate_activities(
     activity: Vec<ActivityParser>,
     pk_node_map: HashMap<PublicKey, NodeInfo>,
-    alias_node_map: HashMap<String, NodeInfo>,
-    get_node_info: impl AsyncFn(&PublicKey) -> Result<NodeInfo, LightningError>,
+    alias_node_map: HashMap<String, Vec<NodeInfo>>,
+    mut graph: Graph,
 ) -> Result<Vec<ActivityDefinition>, LightningError> {
     let mut validated_activities = vec![];
 
+    // Store graph nodes' information keyed by their alias.
+    // An alias can be mapped to multiple nodes because it is not a unique identifier.
+    let mut graph_nodes_by_alias: HashMap<String, Vec<NodeInfo>> = HashMap::new();
+
+    // sort graph nodes by alias for easy lookups.
+    for node in graph.get_nodes()? {
+        if graph_nodes_by_alias.contains_key(&node.1.alias) {
+            if let Some(node_infos) = graph_nodes_by_alias.get(&node.1.alias) {
+                let mut updated_node_infos = node_infos.clone();
+                updated_node_infos.extend(vec![node.1.clone()]);
+                graph_nodes_by_alias.insert(node.1.alias.clone(), vec![node.1]);
+            }
+        } else {
+            graph_nodes_by_alias.insert(node.1.alias.clone(), vec![node.1]);
+        }
+    }
+
     // Make all the activities identifiable by PK internally
     for act in activity.into_iter() {
-        // We can only map aliases to nodes we control, so if either the source or destination alias
+        // We can only map source aliases to nodes we control, so if the source alias
         // is not in alias_node_map, we fail
-        let source = if let Some(source) = match &act.source {
-            NodeId::PublicKey(pk) => pk_node_map.get(pk),
-            NodeId::Alias(a) => alias_node_map.get(a),
-        } {
-            source.clone()
-        } else {
-            return Err(LightningError::ValidationError(format!(
-                "activity source {} not found in nodes.",
-                act.source
-            )));
+        let source = match &act.source {
+            NodeId::PublicKey(pk) => {
+                if let Some(node_info) = pk_node_map.get(pk) {
+                    node_info.clone()
+                } else {
+                    return Err(LightningError::ValidationError(format!(
+                        "activity source {} not found in simulation nodes.",
+                        act.source
+                    )));
+                }
+            },
+            NodeId::Alias(a) => {
+                if let Some(node_infos) = alias_node_map.get(a) {
+                    node_infos[0].clone()
+                } else {
+                    return Err(LightningError::ValidationError(format!(
+                        "activity source {} not found in simulation nodes.",
+                        act.source
+                    )));
+                }
+            },
         };
 
         let destination = match &act.destination {
             NodeId::Alias(a) => {
-                if let Some(info) = alias_node_map.get(a) {
-                    info.clone()
+                if let Some(node_infos) = alias_node_map.get(a) {
+                    node_infos[0].clone()
+                } else if let Some(node_infos) = graph_nodes_by_alias.get(a) {
+                    if node_infos.len() > 1 {
+                        let pks: Vec<PublicKey> = node_infos
+                            .iter()
+                            .map(|node_info| node_info.pubkey)
+                            .collect();
+                        return Err(LightningError::ValidationError(format!(
+                            "Multiple nodes in the graph have the same destination alias - {}. 
+                            Use one of these public keys as the destination instead - {:?}",
+                            a, pks
+                        )));
+                    }
+                    node_infos[0].clone()
                 } else {
                     return Err(LightningError::ValidationError(format!(
                         "unknown activity destination: {}.",
@@ -288,10 +323,15 @@ async fn validate_activities(
                 }
             },
             NodeId::PublicKey(pk) => {
-                if let Some(info) = pk_node_map.get(pk) {
-                    info.clone()
+                if let Some(node_info) = pk_node_map.get(pk) {
+                    node_info.clone()
+                } else if let Some(node_info) = graph.get_node_by_pk(*pk)? {
+                    node_info.clone()
                 } else {
-                    get_node_info(pk).await?
+                    return Err(LightningError::ValidationError(format!(
+                        "unknown activity destination: {}.",
+                        act.destination
+                    )));
                 }
             },
         };

simln-lib/src/cln.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use async_trait::async_trait;
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::Network;
@@ -17,7 +19,8 @@ use tonic::transport::{Certificate, Channel, ClientTlsConfig, Identity};
 use triggered::Listener;
 
 use crate::{
-    serializers, LightningError, LightningNode, NodeId, NodeInfo, PaymentOutcome, PaymentResult,
+    serializers, Graph, LightningError, LightningNode, NodeId, NodeInfo, PaymentOutcome,
+    PaymentResult,
 };
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -263,6 +266,38 @@ impl LightningNode for ClnNode {
         node_channels.extend(self.node_channels(false).await?);
         Ok(node_channels)
     }
+
+    async fn get_graph(&mut self) -> Result<Graph, LightningError> {
+        let nodes: Vec<cln_grpc::pb::ListnodesNodes> = self
+            .client
+            .list_nodes(ListnodesRequest { id: None })
+            .await
+            .map_err(|err| LightningError::GetNodeInfoError(err.to_string()))?
+            .into_inner()
+            .nodes;
+
+        let mut nodes_by_pk: HashMap<PublicKey, NodeInfo> = HashMap::new();
+        let channels = HashMap::new();
+
+        for node in nodes {
+            nodes_by_pk.insert(
+                PublicKey::from_slice(&node.nodeid).expect("Public Key not valid"),
+                NodeInfo {
+                    pubkey: PublicKey::from_slice(&node.nodeid).expect("Public Key not valid"),
+                    alias: node.clone().alias.unwrap_or(String::new()),
+                    features: node
+                        .features
+                        .clone()
+                        .map_or(NodeFeatures::empty(), NodeFeatures::from_be_bytes),
+                },
+            );
+        }
+
+        Ok(Graph {
+            nodes_by_pk,
+            channels,
+        })
+    }
 }
 
 async fn reader(filename: &str) -> Result<Vec<u8>, Error> {

simln-lib/src/eclair.rs

@@ -1,5 +1,6 @@
 use crate::{
-    serializers, LightningError, LightningNode, NodeId, NodeInfo, PaymentOutcome, PaymentResult,
+    serializers, Graph, LightningError, LightningNode, NodeId, NodeInfo, PaymentOutcome,
+    PaymentResult,
 };
 use async_trait::async_trait;
 use bitcoin::secp256k1::PublicKey;
@@ -243,6 +244,33 @@ impl LightningNode for EclairNode {
 
         Ok(capacities_msat)
     }
+
+    async fn get_graph(&mut self) -> Result<Graph, LightningError> {
+        let nodes: NodesResponse = self
+            .client
+            .request("nodes", None)
+            .await
+            .map_err(|err| LightningError::GetNodeInfoError(err.to_string()))?;
+
+        let mut nodes_by_pk: HashMap<PublicKey, NodeInfo> = HashMap::new();
+        let channels = HashMap::new();
+
+        for node in nodes {
+            nodes_by_pk.insert(
+                PublicKey::from_str(&node.node_id).expect("Public Key not valid"),
+                NodeInfo {
+                    pubkey: PublicKey::from_str(&node.node_id).expect("Public Key not valid"),
+                    alias: node.alias.clone(),
+                    features: parse_json_to_node_features(&node.features),
+                },
+            );
+        }
+
+        Ok(Graph {
+            nodes_by_pk,
+            channels,
+        })
+    }
 }
 
 #[derive(Debug, Deserialize)]
@@ -288,7 +316,16 @@ struct NodeResponse {
     announcement: Announcement,
 }
 
+#[derive(Debug, Deserialize)]
+struct NodeInGraph {
+    #[serde(rename = "nodeId")]
+    node_id: String,
+    alias: String,
+    features: Value,
+}
+
 type ChannelsResponse = Vec<Channel>;
+type NodesResponse = Vec<NodeInGraph>;
 
 #[derive(Debug, Deserialize)]
 struct Channel {

simln-lib/src/lib.rs

@@ -284,9 +284,51 @@ impl Display for NodeInfo {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct ChannelInfo {
+    pub channel_id: ShortChannelID,
+    pub capacity_msat: u64,
+}
+
+#[derive(Debug, Clone)]
+/// Graph represents the network graph of the simulated network and is useful for efficient lookups.
+pub struct Graph {
+    // Store nodes' information keyed by their public key.
+    nodes_by_pk: HashMap<PublicKey, NodeInfo>,
+    // Represent channels as a mapping from ShortChannelID to ChannelInfo.
+    #[allow(dead_code)]
+    channels: HashMap<ShortChannelID, ChannelInfo>,
+}
+
+impl Graph {
+    pub fn new() -> Self {
+        Graph {
+            nodes_by_pk: HashMap::new(),
+            channels: HashMap::new(),
+        }
+    }
+
+    pub fn get_nodes(&mut self) -> Result<HashMap<PublicKey, NodeInfo>, LightningError> {
+        Ok(self.nodes_by_pk.clone())
+    }
+
+    pub fn get_node_by_pk(
+        &mut self,
+        public_key: PublicKey,
+    ) -> Result<Option<&NodeInfo>, LightningError> {
+        Ok(self.nodes_by_pk.get(&public_key))
+    }
+}
+
+impl Default for Graph {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// LightningNode represents the functionality that is required to execute events on a lightning node.
 #[async_trait]
-pub trait LightningNode: Send {
+pub trait LightningNode: Send + Sync {
     /// Get information about the node.
     fn get_info(&self) -> &NodeInfo;
     /// Get the network this node is running at.
@@ -308,6 +350,8 @@ pub trait LightningNode: Send {
     /// Lists all channels, at present only returns a vector of channel capacities in msat because no further
     /// information is required.
     async fn list_channels(&mut self) -> Result<Vec<u64>, LightningError>;
+    /// Get the network graph from the point of view of a given node.
+    async fn get_graph(&mut self) -> Result<Graph, LightningError>;
 }
 
 /// Represents an error that occurs when generating a destination for a payment.