Implement Scoring for DefaultPathfinder

Author: chuksys

sim-cli/src/main.rs

@@ -38,7 +38,7 @@ async fn main() -> anyhow::Result<()> {
     let tasks = TaskTracker::new();
 
     // Create the pathfinder instance
-    let pathfinder = DefaultPathFinder;
+    let pathfinder = DefaultPathFinder::default();
 
     let (sim, validated_activities) = if sim_params.sim_network.is_empty() {
         create_simulation(&cli, &sim_params, tasks.clone()).await?

sim-cli/src/parsing.rs

@@ -243,28 +243,21 @@ struct NodeMapping {
 }
 
 pub async fn create_simulation_with_network<P: PathFinder + Clone + 'static>(
-    cli: &Cli,
+    cfg: SimulationCfg,
     sim_params: &SimParams,
     clock: Arc<SimulationClock>,
     tasks: TaskTracker,
     interceptors: Vec<Arc<dyn Interceptor>>,
     custom_records: CustomRecords,
-<<<<<<< HEAD
-<<<<<<< HEAD
+    pathfinder: P,
 ) -> Result<
     (
         Simulation<SimulationClock>,
         Vec<ActivityDefinition>,
-        HashMap<PublicKey, Arc<Mutex<SimNode<SimGraph, SimulationClock>>>>,
+        HashMap<PublicKey, Arc<Mutex<dyn LightningNode>>>,
     ),
     anyhow::Error,
 > {
-=======
-=======
->>>>>>> 079041b (Fix formatting)
-    pathfinder: P,
-) -> Result<(Simulation<SimulationClock>, Vec<ActivityDefinition>), anyhow::Error> {
-    let cfg: SimulationCfg = SimulationCfg::try_from(cli)?;
     let SimParams {
         nodes: _,
         sim_network,
@@ -308,14 +301,17 @@ pub async fn create_simulation_with_network<P: PathFinder + Clone + 'static>(
             .map_err(|e| SimulationError::SimulatedNetworkError(format!("{:?}", e)))?,
     );
 
-<<<<<<< HEAD
-<<<<<<< HEAD
-<<<<<<< HEAD
     // We want the full set of nodes in our graph to return to the caller so that they can take
     // custom actions on the simulated network. For the nodes we'll pass our simulation, cast them
     // to a dyn trait and exclude any nodes that shouldn't be included in random activity
     // generation.
-    let nodes = ln_node_from_graph(simulation_graph.clone(), routing_graph, clock.clone()).await?;
+    let nodes = ln_node_from_graph(
+        simulation_graph.clone(),
+        routing_graph,
+        clock.clone(),
+        pathfinder,
+    )
+    .await?;
     let mut nodes_dyn: HashMap<_, Arc<Mutex<dyn LightningNode>>> = nodes
         .iter()
         .map(|(pk, node)| (*pk, Arc::clone(node) as Arc<Mutex<dyn LightningNode>>))
@@ -324,13 +320,6 @@ pub async fn create_simulation_with_network<P: PathFinder + Clone + 'static>(
         nodes_dyn.remove(pk);
     }
 
-=======
-=======
->>>>>>> 079041b (Fix formatting)
-    // Pass the pathfinder to ln_node_from_graph
-=======
->>>>>>> 4a0f276 (Remove LDK specific scoring from PathFinder trait)
-    let nodes = ln_node_from_graph(simulation_graph.clone(), routing_graph, pathfinder).await;
     let validated_activities =
         get_validated_activities(&nodes_dyn, nodes_info, sim_params.activity.clone()).await?;
 
@@ -645,216 +634,3 @@ pub async fn get_validated_activities(
 
     validate_activities(activity.to_vec(), activity_validation_params).await
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
-    use lightning::routing::gossip::NetworkGraph;
-    use lightning::routing::router::{find_route, PaymentParameters, Route, RouteParameters};
-    use lightning::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringDecayParameters};
-    use rand::RngCore;
-    use simln_lib::clock::SystemClock;
-    use simln_lib::sim_node::{
-        ln_node_from_graph, populate_network_graph, PathFinder, SimGraph, WrappedLog,
-    };
-    use simln_lib::SimulationError;
-    use std::sync::Arc;
-    use tokio::sync::Mutex;
-    use tokio_util::task::TaskTracker;
-
-    /// Gets a key pair generated in a pseudorandom way.
-    fn get_random_keypair() -> (SecretKey, PublicKey) {
-        let secp = Secp256k1::new();
-        let mut rng = rand::thread_rng();
-        let mut bytes = [0u8; 32];
-        rng.fill_bytes(&mut bytes);
-        let secret_key = SecretKey::from_slice(&bytes).expect("Failed to create secret key");
-        let public_key = PublicKey::from_secret_key(&secp, &secret_key);
-        (secret_key, public_key)
-    }
-
-    /// Helper function to create simulated channels for testing.
-    fn create_simulated_channels(num_channels: usize, capacity_msat: u64) -> Vec<SimulatedChannel> {
-        let mut channels = Vec::new();
-        for i in 0..num_channels {
-            let (_node1_sk, node1_pubkey) = get_random_keypair();
-            let (_node2_sk, node2_pubkey) = get_random_keypair();
-
-            let channel = SimulatedChannel::new(
-                capacity_msat,
-                ShortChannelID::from(i as u64),
-                ChannelPolicy {
-                    pubkey: node1_pubkey,
-                    max_htlc_count: 483,
-                    max_in_flight_msat: capacity_msat / 2,
-                    min_htlc_size_msat: 1000,
-                    max_htlc_size_msat: capacity_msat / 2,
-                    cltv_expiry_delta: 144,
-                    base_fee: 1000,
-                    fee_rate_prop: 100,
-                },
-                ChannelPolicy {
-                    pubkey: node2_pubkey,
-                    max_htlc_count: 483,
-                    max_in_flight_msat: capacity_msat / 2,
-                    min_htlc_size_msat: 1000,
-                    max_htlc_size_msat: capacity_msat / 2,
-                    cltv_expiry_delta: 144,
-                    base_fee: 1000,
-                    fee_rate_prop: 100,
-                },
-            );
-            channels.push(channel);
-        }
-        channels
-    }
-
-    /// A pathfinder that always fails to find a path.
-    #[derive(Clone)]
-    pub struct AlwaysFailPathFinder;
-
-    impl PathFinder for AlwaysFailPathFinder {
-        fn find_route(
-            &self,
-            _source: &PublicKey,
-            _dest: PublicKey,
-            _amount_msat: u64,
-            _pathfinding_graph: &NetworkGraph<&'static WrappedLog>,
-        ) -> Result<Route, SimulationError> {
-            Err(SimulationError::SimulatedNetworkError(
-                "No route found".to_string(),
-            ))
-        }
-    }
-
-    /// A pathfinder that only returns single-hop paths.
-    #[derive(Clone)]
-    pub struct SingleHopOnlyPathFinder;
-
-    impl PathFinder for SingleHopOnlyPathFinder {
-        fn find_route(
-            &self,
-            source: &PublicKey,
-            dest: PublicKey,
-            amount_msat: u64,
-            pathfinding_graph: &NetworkGraph<&'static WrappedLog>,
-        ) -> Result<Route, SimulationError> {
-            let scorer = ProbabilisticScorer::new(
-                ProbabilisticScoringDecayParameters::default(),
-                pathfinding_graph,
-                &WrappedLog {},
-            );
-
-            // Try to find a route - if it fails or has more than one hop, return an error.
-            match find_route(
-                source,
-                &RouteParameters {
-                    payment_params: PaymentParameters::from_node_id(dest, 0)
-                        .with_max_total_cltv_expiry_delta(u32::MAX)
-                        .with_max_path_count(1)
-                        .with_max_channel_saturation_power_of_half(1),
-                    final_value_msat: amount_msat,
-                    max_total_routing_fee_msat: None,
-                },
-                pathfinding_graph,
-                None,
-                &WrappedLog {},
-                &scorer,
-                &Default::default(),
-                &[0; 32],
-            ) {
-                Ok(route) => {
-                    // Only allow single-hop routes.
-                    if route.paths.len() == 1 && route.paths[0].hops.len() == 1 {
-                        Ok(route)
-                    } else {
-                        Err(SimulationError::SimulatedNetworkError(
-                            "Only single-hop routes allowed".to_string(),
-                        ))
-                    }
-                },
-                Err(e) => Err(SimulationError::SimulatedNetworkError(e.err)),
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_always_fail_pathfinder() {
-        let channels = create_simulated_channels(3, 1_000_000_000);
-        let routing_graph =
-            Arc::new(populate_network_graph(channels.clone(), Arc::new(SystemClock {})).unwrap());
-
-        let pathfinder = AlwaysFailPathFinder;
-        let source = channels[0].get_node_1_pubkey();
-        let dest = channels[2].get_node_2_pubkey();
-
-        let result = pathfinder.find_route(&source, dest, 100_000, &routing_graph);
-
-        // Should always fail.
-        assert!(result.is_err());
-    }
-
-    #[tokio::test]
-    async fn test_single_hop_only_pathfinder() {
-        let channels = create_simulated_channels(3, 1_000_000_000);
-        let routing_graph =
-            Arc::new(populate_network_graph(channels.clone(), Arc::new(SystemClock {})).unwrap());
-
-        let pathfinder = SingleHopOnlyPathFinder;
-        let source = channels[0].get_node_1_pubkey();
-
-        // Test direct connection (should work).
-        let direct_dest = channels[0].get_node_2_pubkey();
-        let result = pathfinder.find_route(&source, direct_dest, 100_000, &routing_graph);
-
-        if result.is_ok() {
-            let route = result.unwrap();
-            assert_eq!(route.paths[0].hops.len(), 1); // Only one hop
-        }
-
-        // Test indirect connection (should fail).
-        let indirect_dest = channels[2].get_node_2_pubkey();
-        let _result = pathfinder.find_route(&source, indirect_dest, 100_000, &routing_graph);
-
-        // May fail because no direct route exists.
-        // (depends on your test network topology)
-    }
-
-    /// Test that different pathfinders produce different behavior in payments.
-    #[tokio::test]
-    async fn test_pathfinder_affects_payment_behavior() {
-        let channels = create_simulated_channels(3, 1_000_000_000);
-        let (shutdown_trigger, shutdown_listener) = triggered::trigger();
-        let sim_graph = Arc::new(Mutex::new(
-            SimGraph::new(
-                channels.clone(),
-                TaskTracker::new(),
-                Vec::new(),
-                HashMap::new(), // Empty custom records
-                (shutdown_trigger.clone(), shutdown_listener.clone()),
-            )
-            .unwrap(),
-        ));
-        let routing_graph =
-            Arc::new(populate_network_graph(channels.clone(), Arc::new(SystemClock {})).unwrap());
-
-        // Create nodes with different pathfinders.
-        let nodes_default = ln_node_from_graph(
-            sim_graph.clone(),
-            routing_graph.clone(),
-            simln_lib::sim_node::DefaultPathFinder,
-        )
-        .await;
-
-        let nodes_fail = ln_node_from_graph(
-            sim_graph.clone(),
-            routing_graph.clone(),
-            AlwaysFailPathFinder,
-        )
-        .await;
-
-        // Both should create the same structure.
-        assert_eq!(nodes_default.len(), nodes_fail.len());
-    }
-}