Allows aliases within node definition in the config file

Also makes sure that, if a public key is provided, it matches the one obtained
by the backend

sim-cli/src/main.rs

@@ -43,28 +43,28 @@ async fn main() -> anyhow::Result<()> {
         // TODO: We should simplify this into two minimal branches plus shared logging and inserting into the list
         match connection {
             NodeConnection::LND(c) => {
-                let node_id = c.id;
                 let lnd = LndNode::new(c).await?;
+                let node_info = lnd.get_info();
 
                 log::info!(
                     "Connected to {} - Node ID: {}.",
-                    lnd.get_info().alias,
-                    lnd.get_info().pubkey
+                    node_info.alias,
+                    node_info.pubkey
                 );
 
-                clients.insert(node_id, Arc::new(Mutex::new(lnd)));
+                clients.insert(node_info.pubkey, Arc::new(Mutex::new(lnd)));
             }
             NodeConnection::CLN(c) => {
-                let node_id = c.id;
                 let cln = ClnNode::new(c).await?;
+                let node_info = cln.get_info();
 
                 log::info!(
                     "Connected to {} - Node ID: {}.",
-                    cln.get_info().alias,
-                    cln.get_info().pubkey
+                    node_info.alias,
+                    node_info.pubkey
                 );
 
-                clients.insert(node_id, Arc::new(Mutex::new(cln)));
+                clients.insert(node_info.pubkey, Arc::new(Mutex::new(cln)));
             }
         }
     }

sim-lib/src/cln.rs

@@ -57,7 +57,7 @@ impl ClnNode {
 
         let GetinfoResponse {
             id,
-            alias,
+            mut alias,
             our_features,
             ..
         } = client
@@ -66,6 +66,20 @@ impl ClnNode {
             .map_err(|err| LightningError::GetInfoError(err.to_string()))?
             .into_inner();
 
+        let node_id = PublicKey::from_slice(&id).unwrap();
+
+        match connection.id {
+            crate::NodeId::PublicKey(pk) => {
+                if pk != node_id {
+                    return Err(LightningError::ValidationError(format!(
+                    "The provided node id does not match the one returned by the backend ({} != {})",
+                    pk, node_id,
+                )));
+                }
+            }
+            crate::NodeId::Alias(a) => alias = Some(a),
+        }
+
         //FIXME: our_features is returning None, but it should not :S
         let features = if let Some(features) = our_features {
             NodeFeatures::from_le_bytes(features.node)

sim-lib/src/lib.rs

@@ -29,9 +29,16 @@ pub enum NodeConnection {
     CLN(ClnConnection),
 }
 
+#[derive(Serialize, Debug, Clone)]
+pub enum NodeId {
+    PublicKey(PublicKey),
+    Alias(String),
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct LndConnection {
-    pub id: PublicKey,
+    #[serde(with = "serializers::serde_node_id")]
+    pub id: NodeId,
     pub address: String,
     #[serde(deserialize_with = "serializers::deserialize_path")]
     pub macaroon: String,
@@ -41,7 +48,8 @@ pub struct LndConnection {
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ClnConnection {
-    pub id: PublicKey,
+    #[serde(with = "serializers::serde_node_id")]
+    pub id: NodeId,
     pub address: String,
     #[serde(deserialize_with = "serializers::deserialize_path")]
     pub ca_cert: String,
@@ -85,19 +93,19 @@ pub enum SimulationError {
 // Phase 2: Event Queue
 #[derive(Debug, Error)]
 pub enum LightningError {
-    #[error("Node connection error {0}")]
+    #[error("Node connection error: {0}")]
     ConnectionError(String),
-    #[error("Get info error {0}")]
+    #[error("Get info error: {0}")]
     GetInfoError(String),
-    #[error("Send payment error {0}")]
+    #[error("Send payment error: {0}")]
     SendPaymentError(String),
-    #[error("Track payment error {0}")]
+    #[error("Track payment error: {0}")]
     TrackPaymentError(String),
     #[error("Invalid payment hash")]
     InvalidPaymentHash,
-    #[error("Get node info error {0}")]
+    #[error("Get node info error: {0}")]
     GetNodeInfoError(String),
-    #[error("Config validation failed {0}")]
+    #[error("Config validation failed: {0}")]
     ValidationError(String),
     #[error("RPC error: {0:?}")]
     RpcError(#[from] tonic_lnd::tonic::Status),

sim-lib/src/lnd.rs

@@ -42,15 +42,16 @@ fn parse_node_features(features: HashSet<u32>) -> NodeFeatures {
 }
 
 impl LndNode {
-    pub async fn new(conn_data: LndConnection) -> Result<Self, LightningError> {
-        let mut client = tonic_lnd::connect(conn_data.address, conn_data.cert, conn_data.macaroon)
-            .await
-            .map_err(|err| LightningError::ConnectionError(err.to_string()))?;
+    pub async fn new(connection: LndConnection) -> Result<Self, LightningError> {
+        let mut client =
+            tonic_lnd::connect(connection.address, connection.cert, connection.macaroon)
+                .await
+                .map_err(|err| LightningError::ConnectionError(err.to_string()))?;
 
         let GetInfoResponse {
             identity_pubkey,
             features,
-            alias,
+            mut alias,
             ..
         } = client
             .lightning()
@@ -59,6 +60,19 @@ impl LndNode {
             .map_err(|err| LightningError::GetInfoError(err.to_string()))?
             .into_inner();
 
+        let node_id = PublicKey::from_str(&identity_pubkey).unwrap();
+        match connection.id {
+            crate::NodeId::PublicKey(pk) => {
+                if pk != node_id {
+                    return Err(LightningError::ValidationError(format!(
+                    "The provided node id does not match the one returned by the backend ({} != {})",
+                    pk, node_id,
+                )));
+                }
+            }
+            crate::NodeId::Alias(a) => alias = a,
+        }
+
         Ok(Self {
             client,
             info: NodeInfo {

sim-lib/src/serializers.rs

@@ -2,9 +2,8 @@ use expanduser::expanduser;
 use serde::Deserialize;
 
 pub mod serde_payment_hash {
-
+    use super::*;
     use lightning::ln::PaymentHash;
-    use serde::Deserialize;
 
     pub fn serialize<S>(hash: &PaymentHash, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -28,6 +27,36 @@ pub mod serde_payment_hash {
     }
 }
 
+pub mod serde_node_id {
+    use super::*;
+    use std::str::FromStr;
+
+    use crate::NodeId;
+    use bitcoin::secp256k1::PublicKey;
+
+    pub fn serialize<S>(id: &NodeId, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&match id {
+            NodeId::PublicKey(p) => p.to_string(),
+            NodeId::Alias(s) => s.to_string(),
+        })
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<NodeId, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        if let Ok(pk) = PublicKey::from_str(&s) {
+            Ok(NodeId::PublicKey(pk))
+        } else {
+            Ok(NodeId::Alias(s))
+        }
+    }
+}
+
 pub fn deserialize_path<'de, D>(deserializer: D) -> Result<String, D::Error>
 where
     D: serde::Deserializer<'de>,