[NO MERGE]: run simulation with ring of nodes for testing

This commit is not intended for merge, it just spins up a circle of
sim nodes so that we can test this functionality out. It'll be dropped
before merge and replaced with the ability to properly configure your
simulation (likely in a followup PR).

Author: carlaKC

Cargo.lock

@@ -20,3 +20,5 @@ sim-lib = { path = "../sim-lib" }
 tokio = { version = "1.26.0", features = ["full"] }
 bitcoin = { version = "0.30.1" }
 ctrlc = "3.4.0"
+triggered = "0.1.2"
+rand = "0.8.5"

sim-cli/Cargo.toml

@@ -1,4 +1,10 @@
-use bitcoin::secp256k1::PublicKey;
+use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
+use rand::distributions::Uniform;
+use rand::Rng;
+use sim_lib::sim_node::{
+    ln_node_from_graph, populate_network_graph, ChannelPolicy, SimGraph, SimulatedChannel,
+};
+
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -189,7 +195,6 @@ async fn main() -> anyhow::Result<()> {
             amount_msat: act.amount_msat,
         });
     }
-
     let write_results = if !cli.no_results {
         Some(WriteResults {
             results_dir: mkdir(cli.data_dir.join("results")).await?,
@@ -199,8 +204,22 @@ async fn main() -> anyhow::Result<()> {
         None
     };
 
+    let channels = generate_sim_nodes();
+
+    // TODO: use the shutdown trigger and listener across simulator and graph.
+    let (shutdown_trigger, shutdown_listener) = triggered::trigger();
+    let graph = match SimGraph::new(channels.clone(), shutdown_trigger, shutdown_listener) {
+        Ok(graph) => Arc::new(Mutex::new(graph)),
+        Err(e) => anyhow::bail!("failed: {:?}", e),
+    };
+
+    let routing_graph = match populate_network_graph(channels) {
+        Ok(r) => r,
+        Err(e) => anyhow::bail!("failed: {:?}", e),
+    };
+
     let sim = Simulation::new(
-        clients,
+        ln_node_from_graph(graph, Arc::new(routing_graph)).await,
         validated_activities,
         cli.total_time,
         cli.expected_pmt_amt,
@@ -219,6 +238,84 @@ async fn main() -> anyhow::Result<()> {
     Ok(())
 }
 
+fn generate_sim_nodes() -> Vec<SimulatedChannel> {
+    let capacity = 300000000;
+    let mut channels: Vec<SimulatedChannel> = vec![];
+    let (_, first_node) = get_random_keypair();
+
+    // Create channels in a ring so that we'll get long payment paths.
+    let mut node_1 = first_node;
+    for i in 0..10 {
+        // Create a new node that we'll create a channel with. If we're on the last node in the circle, we'll loop
+        // back around to the first node to close it.
+        let node_2 = if i == 10 {
+            first_node
+        } else {
+            let (_, pk) = get_random_keypair();
+            pk
+        };
+
+        let node_1_to_2 = ChannelPolicy {
+            pubkey: node_1,
+            max_htlc_count: 483,
+            max_in_flight_msat: capacity / 2,
+            min_htlc_size_msat: 1,
+            max_htlc_size_msat: capacity / 2,
+            cltv_expiry_delta: 40,
+            // Alter fee rate a little for different values.
+            base_fee: 1000 * i,
+            fee_rate_prop: 1500 * i,
+        };
+
+        let node_2_to_1 = ChannelPolicy {
+            pubkey: node_2,
+            max_htlc_count: 483,
+            max_in_flight_msat: capacity / 2,
+            min_htlc_size_msat: 1,
+            max_htlc_size_msat: capacity / 2,
+            cltv_expiry_delta: 40 + 10 * i as u32,
+            // Alter fee rate a little for different values.
+            base_fee: 2000 * i,
+            fee_rate_prop: i,
+        };
+
+        channels.push(SimulatedChannel::new(
+            capacity,
+            // Unique channel ID per link.
+            100 + i,
+            node_1_to_2,
+            node_2_to_1,
+        ));
+
+        // Once we've created this link in the circle, progress our current node to be node_1 so that we can generate
+        // a new edge.
+        node_1 = node_2;
+    }
+
+    channels
+}
+
+/// COPIED from test utils!
+pub fn get_random_bytes(size: usize) -> Vec<u8> {
+    rand::thread_rng()
+        .sample_iter(Uniform::new(u8::MIN, u8::MAX))
+        .take(size)
+        .collect()
+}
+
+pub fn get_random_int(s: u64, e: u64) -> u64 {
+    rand::thread_rng().gen_range(s..e)
+}
+
+pub fn get_random_keypair() -> (SecretKey, PublicKey) {
+    loop {
+        if let Ok(sk) = SecretKey::from_slice(&get_random_bytes(32)) {
+            return (sk, PublicKey::from_secret_key(&Secp256k1::new(), &sk));
+        }
+    }
+}
+/// COPIED from test utils!
+
 async fn read_sim_path(data_dir: PathBuf, sim_file: PathBuf) -> anyhow::Result<PathBuf> {
     let sim_path = if sim_file.is_relative() {
         data_dir.join(sim_file)