f - use new and add test

Author: elnosh

sim-cli/src/parsing.rs

@@ -172,18 +172,6 @@ pub struct NetworkParser {
     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,
-            false,
-        )
-    }
-}
-
 /// 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)]
@@ -281,10 +269,13 @@ pub async fn create_simulation_with_network(
         .map(|channel| {
             let exclude_capacity = exclude.contains(&channel.node_1.pubkey)
                 || exclude.contains(&channel.node_2.pubkey);
-
-            let mut sim_channel = SimulatedChannel::from(channel);
-            sim_channel.exclude_capacity = exclude_capacity;
-            sim_channel
+            SimulatedChannel::new(
+                channel.capacity_msat,
+                channel.scid,
+                channel.node_1,
+                channel.node_2,
+                exclude_capacity,
+            )
         })
         .collect::<Vec<SimulatedChannel>>();
 

simln-lib/src/sim_node.rs

@@ -319,7 +319,10 @@ pub struct SimulatedChannel {
     short_channel_id: ShortChannelID,
     node_1: ChannelState,
     node_2: ChannelState,
-    pub exclude_capacity: bool,
+    // When excluding nodes from sending and receiving payments in a simulation (only used for
+    // routing) we use this field to also exclude the capacity of the channel so that it is not
+    // counted towards the capacity of a node that we do want to send payments from.
+    exclude_capacity: bool,
 }
 
 impl SimulatedChannel {
@@ -1593,6 +1596,7 @@ impl UtxoLookup for UtxoValidator {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::clock::SimulationClock;
     use crate::clock::SystemClock;
     use crate::test_utils::get_random_keypair;
     use lightning::routing::router::build_route_from_hops;
@@ -1602,6 +1606,7 @@ mod tests {
     use std::time::Duration;
     use tokio::sync::oneshot;
     use tokio::time::{self, timeout};
+    use triggered::trigger;
 
     /// Creates a test channel policy with its maximum HTLC size set to half of the in flight limit of the channel.
     /// The minimum HTLC size is hardcoded to 2 so that we can fall beneath this value with a 1 msat htlc.
@@ -1902,6 +1907,94 @@ mod tests {
         ));
     }
 
+    #[tokio::test]
+    async fn test_excluded_channel_balance() {
+        let capacity_1 = 200_000_000;
+        let capacity_2 = 300_000_000;
+
+        let pk1 = get_random_keypair().1;
+        let pk2 = get_random_keypair().1;
+        let pk3 = get_random_keypair().1;
+
+        let create_policy = |max_in_flight_msat: u64, pubkey: PublicKey| -> ChannelPolicy {
+            ChannelPolicy {
+                pubkey,
+                alias: String::default(),
+                max_htlc_count: 10,
+                max_in_flight_msat,
+                min_htlc_size_msat: 2,
+                max_htlc_size_msat: max_in_flight_msat / 2,
+                cltv_expiry_delta: 10,
+                base_fee: 1000,
+                fee_rate_prop: 5000,
+            }
+        };
+
+        let channels = vec![
+            SimulatedChannel::new(
+                capacity_1,
+                ShortChannelID::from(1),
+                create_policy(capacity_1 / 2, pk1),
+                create_policy(capacity_1 / 2, pk2),
+                false,
+            ),
+            SimulatedChannel::new(
+                capacity_2,
+                ShortChannelID::from(2),
+                create_policy(capacity_2 / 2, pk1),
+                create_policy(capacity_2 / 2, pk3),
+                true,
+            ),
+        ];
+
+        let sim_graph = Arc::new(Mutex::new(
+            SimGraph::new(
+                channels.clone(),
+                TaskTracker::new(),
+                Vec::new(),
+                CustomRecords::default(),
+                trigger(),
+            )
+            .unwrap(),
+        ));
+
+        let clock = Arc::new(SimulationClock::new(1).unwrap());
+        let routing_graph = Arc::new(populate_network_graph(channels, Arc::clone(&clock)).unwrap());
+
+        let nodes = ln_node_from_graph(sim_graph, routing_graph, clock)
+            .await
+            .unwrap();
+
+        let node_1_channels = nodes
+            .get(&pk1)
+            .unwrap()
+            .lock()
+            .await
+            .list_channels()
+            .await
+            .unwrap();
+
+        // Node 1 has 2 channels but one was excluded so here we should only have the one that was
+        // not excluded.
+        assert!(node_1_channels.len() == 1);
+        assert!(node_1_channels[0] == capacity_1);
+
+        let node_2_channels = nodes
+            .get(&pk2)
+            .unwrap()
+            .lock()
+            .await
+            .list_channels()
+            .await
+            .unwrap();
+
+        assert!(node_2_channels.len() == 1);
+        assert!(node_2_channels[0] == capacity_1);
+
+        // Node 3's only channel was excluded so it won't be present here.
+        assert!(nodes.get(&pk3).is_none());
+    }
+
     /// Tests basic functionality of a `SimulatedChannel` but does no endeavor to test the underlying
     /// `ChannelState`, as this is covered elsewhere in our tests.
     #[test]