simln-lib: repurpose list_channels to channel_capacities

Currently, list_channels is only used for returning a list
of channel capacities and using that to determine how much
the node should send in a month. Change it to channel_capacities
that will return the sum of the capacities of the channels
that should be taken into account.

Author: elnosh

simln-lib/src/cln.rs

@@ -264,10 +264,10 @@ impl LightningNode for ClnNode {
         }
     }
 
-    async fn list_channels(&self) -> Result<Vec<u64>, LightningError> {
+    async fn channel_capacities(&self) -> Result<u64, LightningError> {
         let mut node_channels = self.node_channels(true).await?;
         node_channels.extend(self.node_channels(false).await?);
-        Ok(node_channels)
+        Ok(node_channels.iter().sum())
     }
 
     async fn get_graph(&self) -> Result<Graph, LightningError> {

simln-lib/src/eclair.rs

@@ -222,7 +222,7 @@ impl LightningNode for EclairNode {
         })
     }
 
-    async fn list_channels(&self) -> Result<Vec<u64>, LightningError> {
+    async fn channel_capacities(&self) -> Result<u64, LightningError> {
         let client = self.client.lock().await;
         let channels: ChannelsResponse = client
             .request("channels", None)
@@ -242,7 +242,7 @@ impl LightningNode for EclairNode {
             })
             .collect();
 
-        Ok(capacities_msat)
+        Ok(capacities_msat.iter().sum())
     }
 
     async fn get_graph(&self) -> Result<Graph, LightningError> {

simln-lib/src/lib.rs

@@ -343,9 +343,9 @@ pub trait LightningNode: Send {
     ) -> Result<PaymentResult, LightningError>;
     /// Gets information on a specific node.
     async fn get_node_info(&self, node_id: &PublicKey) -> Result<NodeInfo, LightningError>;
-    /// Lists all channels, at present only returns a vector of channel capacities in msat because no further
-    /// information is required.
-    async fn list_channels(&self) -> Result<Vec<u64>, LightningError>;
+    /// Sum of channel capacities. This is used when running with random activity generation to
+    /// determine how much the node will send per month.
+    async fn channel_capacities(&self) -> Result<u64, LightningError>;
     /// Get the network graph from the point of view of a given node.
     async fn get_graph(&self) -> Result<Graph, LightningError>;
 }
@@ -1003,7 +1003,7 @@ impl<C: Clock + 'static> Simulation<C> {
         // While we're at it, we get the node info and store it with capacity to create activity generators in our
         // second pass.
         for (pk, node) in self.nodes.iter() {
-            let chan_capacity = node.lock().await.list_channels().await?.iter().sum::<u64>();
+            let chan_capacity = node.lock().await.channel_capacities().await?;
 
             if let Err(e) = RandomPaymentActivity::validate_capacity(
                 chan_capacity,
@@ -1935,8 +1935,8 @@ mod tests {
             .expect_get_network()
             .returning(|| Network::Regtest);
         mock_node
-            .expect_list_channels()
-            .returning(|| Ok(vec![100_000_000]));
+            .expect_channel_capacities()
+            .returning(|| Ok(100_000_000));
         mock_node
             .expect_get_node_info()
             .returning(move |_| Ok(node_info.clone()));

simln-lib/src/lnd.rs

@@ -252,7 +252,7 @@ impl LightningNode for LndNode {
         }
     }
 
-    async fn list_channels(&self) -> Result<Vec<u64>, LightningError> {
+    async fn channel_capacities(&self) -> Result<u64, LightningError> {
         let mut client = self.client.lock().await;
         let channels = client
             .lightning()
@@ -268,7 +268,7 @@ impl LightningNode for LndNode {
             .channels
             .iter()
             .map(|channel| 1000 * channel.capacity as u64)
-            .collect())
+            .sum())
     }
 
     async fn get_graph(&self) -> Result<Graph, LightningError> {

simln-lib/src/sim_node.rs

@@ -797,8 +797,9 @@ impl<T: SimNetwork, C: Clock> LightningNode for SimNode<T, C> {
         Ok(self.network.lock().await.lookup_node(node_id)?.0)
     }
 
-    async fn list_channels(&self) -> Result<Vec<u64>, LightningError> {
-        Ok(self.network.lock().await.lookup_node(&self.info.pubkey)?.1)
+    async fn channel_capacities(&self) -> Result<u64, LightningError> {
+        let channels = self.network.lock().await.lookup_node(&self.info.pubkey)?;
+        Ok(channels.1.iter().sum())
     }
 
     async fn get_graph(&self) -> Result<Graph, LightningError> {
@@ -1965,31 +1966,16 @@ mod tests {
             .await
             .unwrap();
 
-        let node_1_channels = nodes
-            .get(&pk1)
-            .unwrap()
-            .lock()
-            .await
-            .list_channels()
-            .await
-            .unwrap();
+        let node_1 = nodes.get(&pk1).unwrap().lock().await;
+        let node_1_capacity = node_1.channel_capacities().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_1_capacity == capacity_1);
 
-        assert!(node_2_channels.len() == 1);
-        assert!(node_2_channels[0] == capacity_1);
+        let node_2 = nodes.get(&pk2).unwrap().lock().await;
+        let node_2_capacity = node_2.channel_capacities().await.unwrap();
+        assert!(node_2_capacity == capacity_1);
 
         // Node 3's only channel was excluded so it won't be present here.
         assert!(!nodes.contains_key(&pk3));
@@ -2103,12 +2089,17 @@ mod tests {
             .lock()
             .await
             .expect_lookup_node()
-            .returning(move |_| Ok((node_info(lookup_pk, String::default()), vec![1, 2, 3])));
+            .returning(move |_| {
+                Ok((
+                    node_info(lookup_pk, String::default()),
+                    vec![10_000, 20_000, 10_000],
+                ))
+            });
 
         // Assert that we get three channels from the mock.
         let node_info = node.get_node_info(&lookup_pk).await.unwrap();
         assert_eq!(lookup_pk, node_info.pubkey);
-        assert_eq!(node.list_channels().await.unwrap().len(), 3);
+        assert_eq!(node.channel_capacities().await.unwrap(), 40_000);
 
         // Next, we're going to test handling of in-flight payments. To do this, we'll mock out calls to our dispatch
         // function to send different results depending on the destination.

simln-lib/src/test_utils.rs

@@ -89,7 +89,7 @@ mock! {
                 shutdown: triggered::Listener,
             ) -> Result<crate::PaymentResult, LightningError>;
         async fn get_node_info(&self, node_id: &PublicKey) -> Result<NodeInfo, LightningError>;
-        async fn list_channels(&self) -> Result<Vec<u64>, LightningError>;
+        async fn channel_capacities(&self) -> Result<u64, LightningError>;
         async fn get_graph(&self) -> Result<Graph, LightningError>;
     }
 }