simln-lib/feature: Add ability to run with mocked ln network

Author: f3r10

sim-cli/src/main.rs

@@ -20,7 +20,7 @@ async fn main() -> anyhow::Result<()> {
         .init()
         .unwrap();
 
-    let sim = create_simulation(&cli).await?;
+    let (sim, sim_network) = create_simulation(&cli).await?;
     let sim2 = sim.clone();
 
     ctrlc::set_handler(move || {
@@ -30,5 +30,9 @@ async fn main() -> anyhow::Result<()> {
 
     sim.run().await?;
 
+    if let Some(network) = sim_network {
+        network.lock().await.tasks.wait().await;
+    }
+
     Ok(())
 }

sim-cli/src/parsing.rs

@@ -3,6 +3,8 @@ use bitcoin::secp256k1::PublicKey;
 use clap::{builder::TypedValueParser, Parser};
 use log::LevelFilter;
 use serde::{Deserialize, Serialize};
+use simln_lib::sim_node::{node_info, ChannelPolicy, SimGraph, SimulatedChannel};
+use simln_lib::ShortChannelID;
 use simln_lib::{
     cln, cln::ClnNode, eclair, eclair::EclairNode, lnd, lnd::LndNode, serializers,
     ActivityDefinition, Amount, Interval, LightningError, LightningNode, NodeId, NodeInfo,
@@ -83,8 +85,11 @@ pub struct Cli {
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 struct SimParams {
+    #[serde(default)]
     pub nodes: Vec<NodeConnection>,
     #[serde(default)]
+    pub sim_network: Vec<NetworkParser>,
+    #[serde(default)]
     pub activity: Vec<ActivityParser>,
 }
 
@@ -96,6 +101,27 @@ enum NodeConnection {
     Eclair(eclair::EclairConnection),
 }
 
+/// Data structure that is used to parse information from the simulation file, used to pair two node policies together
+/// without the other internal state that is used in our simulated network.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NetworkParser {
+    pub scid: ShortChannelID,
+    pub capacity_msat: u64,
+    pub node_1: ChannelPolicy,
+    pub node_2: ChannelPolicy,
+}
+
+impl From<NetworkParser> for SimulatedChannel {
+    fn from(network_parser: NetworkParser) -> Self {
+        SimulatedChannel::new(
+            network_parser.capacity_msat,
+            network_parser.scid,
+            network_parser.node_1,
+            network_parser.node_2,
+        )
+    }
+}
+
 /// Data structure used to parse information from the simulation file. It allows source and destination to be
 /// [NodeId], which enables the use of public keys and aliases in the simulation description.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -142,11 +168,11 @@ impl TryFrom<&Cli> for SimulationCfg {
 
 /// Parses the cli options provided and creates a simulation to be run, connecting to lightning nodes and validating
 /// any activity described in the simulation file.
-pub async fn create_simulation(cli: &Cli) -> Result<Simulation, anyhow::Error> {
+pub async fn create_simulation(cli: &Cli) -> Result<(Simulation, Option<Arc<Mutex<SimGraph>>>), anyhow::Error> {
     let cfg: SimulationCfg = SimulationCfg::try_from(cli)?;
 
     let sim_path = read_sim_path(cli.data_dir.clone(), cli.sim_file.clone()).await?;
-    let SimParams { nodes, activity } = serde_json::from_str(&std::fs::read_to_string(sim_path)?)
+    let SimParams { nodes, sim_network, activity} = serde_json::from_str(&std::fs::read_to_string(sim_path)?)
         .map_err(|e| {
         anyhow!(
             "Could not deserialize node connection data or activity description from simulation file (line {}, col {}, err: {}).",
@@ -156,23 +182,71 @@ 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(),
+    // Validate that nodes and sim_graph are exclusively set, and setup node clients from the populated field.
+    if !nodes.is_empty() && !sim_network.is_empty() {
+        Err(anyhow!(
+                "Simulation file cannot contain {} nodes and {} sim_graph entries, simulation can only be run with real 
+            or simulated nodes not both.", nodes.len(), sim_network.len(),
         ))
-    };
+    } else if nodes.is_empty() && sim_network.is_empty() {
+        Err(anyhow!(
+                "Simulation file must contain nodes to run with real lightning nodes or sim_graph to run with 
+                simulated nodes",
+        ))
+    } else if !nodes.is_empty() {
+        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;
+            }
 
-    let validated_activities = validate_activities(activity, &clients_info, get_node).await?;
-    let tasks = TaskTracker::new();
+            Err(LightningError::GetNodeInfoError(
+                "no nodes for query".to_string(),
+            ))
+        };
 
-    Ok(Simulation::new(cfg, clients, validated_activities, tasks))
+        let validated_activities = validate_activities(activity, &clients_info, get_node).await?;
+        let tasks = TaskTracker::new();
+
+        Ok((Simulation::new(cfg, clients, validated_activities, tasks), None))
+    } else {
+        // Convert nodes representation for parsing to SimulatedChannel
+        let channels = sim_network
+            .clone()
+            .into_iter()
+            .map(SimulatedChannel::from)
+            .collect::<Vec<SimulatedChannel>>();
+
+        let mut nodes_info = HashMap::new();
+        for sim_channel in sim_network {
+            nodes_info.insert(
+                sim_channel.node_1.pubkey,
+                node_info(sim_channel.node_1.pubkey),
+            );
+            nodes_info.insert(
+                sim_channel.node_2.pubkey,
+                node_info(sim_channel.node_2.pubkey),
+            );
+        }
+        let get_node_info = async |pk: &PublicKey| -> Result<NodeInfo, LightningError> {
+            if let Some(node) = nodes_info.get(pk) {
+                Ok(node_info(node.pubkey))
+            } else {
+                Err(LightningError::GetNodeInfoError(format!(
+                    "node not found in simulated network: {}",
+                    pk
+                )))
+            }
+        };
+        let validated_activities =
+            validate_activities(activity, &nodes_info, get_node_info).await?;
+        let tasks = TaskTracker::new();
+        let (simulation, graph) =
+            Simulation::new_with_sim_network(cfg, channels, validated_activities, tasks).await?;
+        Ok((simulation, Some(graph)))
+    }
 }
 
 /// Connects to the set of nodes providing, returning a map of node public keys to LightningNode implementations and

simln-lib/src/lib.rs

@@ -9,6 +9,7 @@ use rand::{Rng, RngCore, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 use random_activity::RandomActivityError;
 use serde::{Deserialize, Serialize};
+use sim_node::{ln_node_from_graph, populate_network_graph, SimGraph, SimulatedChannel};
 use std::collections::HashSet;
 use std::fmt::{Display, Formatter};
 use std::marker::Send;
@@ -90,7 +91,7 @@ impl std::fmt::Display for NodeId {
 }
 
 /// Represents a short channel ID, expressed as a struct so that we can implement display for the trait.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Copy)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Copy, Serialize, Deserialize)]
 pub struct ShortChannelID(u64);
 
 /// Utility function to easily convert from u64 to `ShortChannelID`
@@ -527,6 +528,42 @@ impl Simulation {
         }
     }
 
+    pub async fn new_with_sim_network(
+        cfg: SimulationCfg,
+        channels: Vec<SimulatedChannel>,
+        activity: Vec<ActivityDefinition>,
+        tasks: TaskTracker,
+    ) -> Result<(Simulation, Arc<Mutex<SimGraph>>), SimulationError> {
+        let (shutdown_trigger, shutdown_listener) = triggered::trigger();
+
+        // Setup a simulation graph that will handle propagation of payments through the network
+        let simulation_graph = Arc::new(Mutex::new(
+            SimGraph::new(channels.clone(), tasks.clone(), shutdown_trigger.clone())
+                .map_err(|e| SimulationError::SimulatedNetworkError(format!("{:?}", e)))?,
+        ));
+
+        // Copy all simulated channels into a read-only routing graph, allowing to pathfind for
+        // individual payments without locking th simulation graph (this is a duplication of the channels, but the performance tradeoff is worthwhile for concurrent pathfinding).
+        let routing_graph = Arc::new(
+            populate_network_graph(channels)
+                .map_err(|e| SimulationError::SimulatedNetworkError(format!("{:?}", e)))?,
+        );
+
+        let nodes = ln_node_from_graph(simulation_graph.clone(), routing_graph).await;
+        Ok((
+            Self {
+                nodes,
+                activity,
+                results: Arc::new(Mutex::new(PaymentResultLogger::new())),
+                tasks,
+                shutdown_trigger,
+                shutdown_listener,
+                cfg,
+            },
+            simulation_graph,
+        ))
+    }
+
     /// validate_activity validates that the user-provided activity description is achievable for the network that
     /// we're working with. If no activity description is provided, then it ensures that we have configured a network
     /// that is suitable for random activity generation.

simln-lib/src/sim_node.rs

@@ -6,6 +6,7 @@ use bitcoin::constants::ChainHash;
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::{Network, ScriptBuf, TxOut};
 use lightning::ln::chan_utils::make_funding_redeemscript;
+use serde::{Deserialize, Serialize};
 use std::collections::{hash_map::Entry, HashMap};
 use std::sync::Arc;
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -109,7 +110,7 @@ struct Htlc {
 /// Represents one node in the channel's forwarding policy and restrictions. Note that this doesn't directly map to
 /// a single concept in the protocol, a few things have been combined for the sake of simplicity. Used to manage the
 /// lightning "state machine" and check that HTLCs are added in accordance of the advertised policy.
-#[derive(Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ChannelPolicy {
     pub pubkey: PublicKey,
     pub max_htlc_count: u64,
@@ -488,7 +489,7 @@ impl<'a, T: SimNetwork> SimNode<'a, T> {
 }
 
 /// Produces the node info for a mocked node, filling in the features that the simulator requires.
-fn node_info(pubkey: PublicKey) -> NodeInfo {
+pub fn node_info(pubkey: PublicKey) -> NodeInfo {
     // Set any features that the simulator requires here.
     let mut features = NodeFeatures::empty();
     features.set_keysend_optional();
@@ -654,7 +655,7 @@ pub struct SimGraph {
 
     /// track all tasks spawned to process payments in the graph. Note that handling the shutdown of tasks
     /// in this tracker must be done externally.
-    tasks: TaskTracker,
+    pub tasks: TaskTracker,
 
     /// trigger shutdown if a critical error occurs.
     shutdown_trigger: Trigger,