sim-lib: add SimNode implementation of LightningNode

Add an implementation of the LightningNode trait that represents
the underlying lightning node. This implementation is intentionally
kept simple, depending on some SimNetwork trait to handle the mechanics
of actually simulating the flow of payments through a simulated graph.

Author: carlaKC

sim-lib/src/sim_node.rs

@@ -1,6 +1,24 @@
-use bitcoin::secp256k1::PublicKey;
-use lightning::ln::PaymentHash;
+use crate::{LightningError, LightningNode, NodeInfo, PaymentOutcome, PaymentResult};
+use async_trait::async_trait;
+use bitcoin::Network;
+use bitcoin::{
+    hashes::{sha256::Hash as Sha256, Hash},
+    secp256k1::PublicKey,
+};
+use lightning::ln::features::NodeFeatures;
+use lightning::ln::msgs::LightningError as LdkError;
+use lightning::ln::{PaymentHash, PaymentPreimage};
+use lightning::routing::gossip::NetworkGraph;
+use lightning::routing::router::{find_route, PaymentParameters, Route, RouteParameters};
+use lightning::routing::scoring::ProbabilisticScorer;
+use lightning::util::logger::{Level, Logger, Record};
+use std::collections::hash_map::Entry;
 use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::select;
+use tokio::sync::oneshot::{channel, Receiver, Sender};
+use tokio::sync::Mutex;
+use triggered::Listener;
 
 use crate::ShortChannelID;
 
@@ -338,3 +356,224 @@ impl SimulatedChannel {
             .check_htlc_forward(cltv_delta, amount_msat, fee_msat)
     }
 }
+
+/// SimNetwork represents a high level network coordinator that is responsible for the task of actually propagating
+/// payments through the simulated network.
+#[async_trait]
+trait SimNetwork: Send + Sync {
+    /// Sends payments over the route provided through the network, reporting the final payment outcome to the sender
+    /// channel provided.
+    fn dispatch_payment(
+        &mut self,
+        source: PublicKey,
+        route: Route,
+        payment_hash: PaymentHash,
+        sender: Sender<Result<PaymentResult, LightningError>>,
+    );
+
+    /// Looks up a node in the simulated network and a list of its channel capacities.
+    async fn lookup_node(&self, node: &PublicKey) -> Result<(NodeInfo, Vec<u64>), LightningError>;
+}
+
+/// A wrapper struct used to implement the LightningNode trait (can be thought of as "the" lightning node). Passes
+/// all functionality through to a coordinating simulation network. This implementation contains both the [`SimNetwork`]
+/// implementation that will allow us to dispatch payments and a read-only NetworkGraph that is used for pathfinding.
+/// While these two could be combined, we re-use the LDK-native struct to allow re-use of their pathfinding logic.
+struct SimNode<'a, T: SimNetwork> {
+    info: NodeInfo,
+    /// The underlying execution network that will be responsible for dispatching payments.
+    network: Arc<Mutex<T>>,
+    /// Tracks the channel that will provide updates for payments by hash.
+    in_flight: HashMap<PaymentHash, Receiver<Result<PaymentResult, LightningError>>>,
+    /// A read-only graph used for pathfinding.
+    pathfinding_graph: Arc<NetworkGraph<&'a WrappedLog>>,
+}
+
+impl<'a, T: SimNetwork> SimNode<'a, T> {
+    /// Creates a new simulation node that refers to the high level network coordinator provided to process payments
+    /// on its behalf. The pathfinding graph is provided separately so that each node can handle its own pathfinding.
+    pub fn new(
+        pubkey: PublicKey,
+        payment_network: Arc<Mutex<T>>,
+        pathfinding_graph: Arc<NetworkGraph<&'a WrappedLog>>,
+    ) -> Self {
+        SimNode {
+            info: node_info(pubkey),
+            network: payment_network,
+            in_flight: HashMap::new(),
+            pathfinding_graph,
+        }
+    }
+}
+
+/// Produces the node info for a mocked node, filling in the features that the simulator requires.
+fn node_info(pubkey: PublicKey) -> NodeInfo {
+    // Set any features that the simulator requires here.
+    let mut features = NodeFeatures::empty();
+    features.set_keysend_optional();
+
+    NodeInfo {
+        pubkey,
+        alias: "".to_string(), // TODO: store alias?
+        features,
+    }
+}
+
+/// Uses LDK's pathfinding algorithm with default parameters to find a path from source to destination, with no
+/// restrictions on fee budget.
+fn find_payment_route(
+    source: &PublicKey,
+    dest: PublicKey,
+    amount_msat: u64,
+    pathfinding_graph: &NetworkGraph<&WrappedLog>,
+) -> Result<Route, LdkError> {
+    let scorer = ProbabilisticScorer::new(Default::default(), pathfinding_graph, &WrappedLog {});
+
+    find_route(
+        source,
+        &RouteParameters {
+            payment_params: PaymentParameters::from_node_id(dest, 0)
+                .with_max_total_cltv_expiry_delta(u32::MAX)
+                // TODO: set non-zero value to support MPP.
+                .with_max_path_count(1)
+                // Allow sending htlcs up to 50% of the channel's capacity.
+                .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],
+    )
+}
+
+#[async_trait]
+impl<T: SimNetwork> LightningNode for SimNode<'_, T> {
+    fn get_info(&self) -> &NodeInfo {
+        &self.info
+    }
+
+    async fn get_network(&mut self) -> Result<Network, LightningError> {
+        Ok(Network::Regtest)
+    }
+
+    /// send_payment picks a random preimage for a payment, dispatches it in the network and adds a tracking channel
+    /// to our node state to be used for subsequent track_payment calls.
+    async fn send_payment(
+        &mut self,
+        dest: PublicKey,
+        amount_msat: u64,
+    ) -> Result<PaymentHash, LightningError> {
+        // Create a sender and receiver pair that will be used to report the results of the payment and add them to
+        // our internal tracking state along with the chosen payment hash.
+        let (sender, receiver) = channel();
+        let preimage = PaymentPreimage(rand::random());
+        let payment_hash = PaymentHash(Sha256::hash(&preimage.0).to_byte_array());
+
+        // Check for payment hash collision, failing the payment if we happen to repeat one.
+        match self.in_flight.entry(payment_hash) {
+            Entry::Occupied(_) => {
+                return Err(LightningError::SendPaymentError(
+                    "payment hash exists".to_string(),
+                ));
+            },
+            Entry::Vacant(vacant) => {
+                vacant.insert(receiver);
+            },
+        }
+
+        let route = match find_payment_route(
+            &self.info.pubkey,
+            dest,
+            amount_msat,
+            &self.pathfinding_graph,
+        ) {
+            Ok(path) => path,
+            // In the case that we can't find a route for the payment, we still report a successful payment *api call*
+            // and report RouteNotFound to the tracking channel. This mimics the behavior of real nodes.
+            Err(e) => {
+                log::trace!("Could not find path for payment: {:?}.", e);
+
+                if let Err(e) = sender.send(Ok(PaymentResult {
+                    htlc_count: 0,
+                    payment_outcome: PaymentOutcome::RouteNotFound,
+                })) {
+                    log::error!("Could not send payment result: {:?}.", e);
+                }
+
+                return Ok(payment_hash);
+            },
+        };
+
+        // If we did successfully obtain a route, dispatch the payment through the network and then report success.
+        self.network
+            .lock()
+            .await
+            .dispatch_payment(self.info.pubkey, route, payment_hash, sender);
+
+        Ok(payment_hash)
+    }
+
+    /// track_payment blocks until a payment outcome is returned for the payment hash provided, or the shutdown listener
+    /// provided is triggered. This call will fail if the hash provided was not obtained by calling send_payment first.
+    async fn track_payment(
+        &mut self,
+        hash: PaymentHash,
+        listener: Listener,
+    ) -> Result<PaymentResult, LightningError> {
+        match self.in_flight.remove(&hash) {
+            Some(receiver) => {
+                select! {
+                    biased;
+                    _ = listener => Err(
+                        LightningError::TrackPaymentError("shutdown during payment tracking".to_string()),
+                    ),
+
+                    // If we get a payment result back, remove from our in flight set of payments and return the result.
+                    res = receiver => {
+                        res.map_err(|e| LightningError::TrackPaymentError(format!("channel receive err: {}", e)))?
+                    },
+                }
+            },
+            None => Err(LightningError::TrackPaymentError(format!(
+                "payment hash {} not found",
+                hex::encode(hash.0),
+            ))),
+        }
+    }
+
+    async fn get_node_info(&mut self, node_id: &PublicKey) -> Result<NodeInfo, LightningError> {
+        Ok(self.network.lock().await.lookup_node(node_id).await?.0)
+    }
+
+    async fn list_channels(&mut self) -> Result<Vec<u64>, LightningError> {
+        Ok(self
+            .network
+            .lock()
+            .await
+            .lookup_node(&self.info.pubkey)
+            .await?
+            .1)
+    }
+}
+
+/// WrappedLog implements LDK's logging trait so that we can provide pathfinding with a logger that uses our existing
+/// logger.
+pub struct WrappedLog {}
+
+impl Logger for WrappedLog {
+    fn log(&self, record: Record) {
+        match record.level {
+            Level::Gossip => log::trace!("{}", record.args),
+            Level::Trace => log::trace!("{}", record.args),
+            Level::Debug => log::debug!("{}", record.args),
+            // LDK has quite noisy info logging for pathfinding, so we downgrade their info logging to our debug level.
+            Level::Info => log::debug!("{}", record.args),
+            Level::Warn => log::warn!("{}", record.args),
+            Level::Error => log::error!("{}", record.args),
+        }
+    }
+}