Improve diagnostics message in P2P

- In response message, some of the wrapping elements were missing.
- Added public node key to response, so that each node / response can
  be identified.

crates/node/src/main.rs

@@ -180,6 +180,8 @@ impl workflow::TransactionStore for storage::Database {
 }
 
 async fn run(config: Arc<Config>) -> Result<()> {
+    let node_key = read_node_key(&config.node_key_file)?;
+
     let database = Arc::new(Database::new(&config.db_url).await?);
 
     let http_peer_list: Arc<tokio::sync::RwLock<HashMap<SocketAddr, Option<u16>>>> =
@@ -213,11 +215,13 @@ async fn run(config: Arc<Config>) -> Result<()> {
         });
     }
 
+    let public_node_key = PublicKey::from_secret_key(&node_key);
     let p2p = Arc::new(
         networking::P2P::new(
             "gevulot-p2p-network",
             config.p2p_listen_addr,
             &config.p2p_psk_passphrase,
+            public_node_key,
             Some(config.http_download_port),
             config.p2p_advertised_listen_addr,
             http_peer_list,
@@ -246,8 +250,6 @@ async fn run(config: Arc<Config>) -> Result<()> {
         resource_manager.clone(),
     );
 
-    let node_key = read_node_key(&config.node_key_file)?;
-
     let workflow_engine = Arc::new(WorkflowEngine::new(database.clone()));
     let download_url_prefix = format!(
         "http://{}:{}",
@@ -337,6 +339,7 @@ async fn p2p_beacon(config: P2PBeaconConfig) -> Result<()> {
             "gevulot-network",
             config.p2p_listen_addr,
             &config.p2p_psk_passphrase,
+            PublicKey::from_secret_key(&SecretKey::default()), // P2P beacons don't need the key atm.
             None,
             config.p2p_advertised_listen_addr,
             http_peer_list,

crates/node/src/networking/p2p/pea2pea.rs

@@ -1,6 +1,7 @@
 use crate::txvalidation::P2pSender;
 use crate::txvalidation::TxEventSender;
 use futures_util::Stream;
+use libsecp256k1::PublicKey;
 use std::{
     collections::{BTreeSet, HashMap},
     io,
@@ -42,6 +43,7 @@ pub struct P2P {
     http_port: Option<u16>,
     nat_listen_addr: Option<SocketAddr>,
     psk: Vec<u8>,
+    public_node_key: PublicKey,
 
     // Send Tx to the process loop.
     tx_sender: TxEventSender<P2pSender>,
@@ -59,6 +61,7 @@ impl P2P {
         name: &str,
         listen_addr: SocketAddr,
         psk_passphrase: &str,
+        public_node_key: PublicKey,
         http_port: Option<u16>,
         nat_listen_addr: Option<SocketAddr>,
         peer_http_port_list: Arc<tokio::sync::RwLock<HashMap<SocketAddr, Option<u16>>>>,
@@ -83,6 +86,7 @@ impl P2P {
             node,
             noise_states: Default::default(),
             psk: psk.to_vec(),
+            public_node_key,
             peer_list: Default::default(),
             peer_addr_mapping: Default::default(),
             peer_http_port_list,
@@ -163,16 +167,19 @@ impl P2P {
         source: SocketAddr,
         req: protocol::DiagnosticsRequestKind,
     ) -> io::Result<()> {
-        let resp = protocol::DiagnosticsResponseV0::Version {
-            major: env!("CARGO_PKG_VERSION_MAJOR").parse::<u16>().unwrap(),
-            minor: env!("CARGO_PKG_VERSION_MINOR").parse::<u16>().unwrap(),
-            patch: env!("CARGO_PKG_VERSION_PATCH").parse::<u16>().unwrap(),
-            build: format!(
-                "{}: {}",
-                env!("VERGEN_BUILD_TIMESTAMP"),
-                env!("VERGEN_GIT_DESCRIBE")
-            ),
-        };
+        let resp = protocol::Message::V0(protocol::MessageV0::DiagnosticsResponse(
+            self.public_node_key,
+            protocol::DiagnosticsResponseV0::Version {
+                major: env!("CARGO_PKG_VERSION_MAJOR").parse::<u16>().unwrap(),
+                minor: env!("CARGO_PKG_VERSION_MINOR").parse::<u16>().unwrap(),
+                patch: env!("CARGO_PKG_VERSION_PATCH").parse::<u16>().unwrap(),
+                build: format!(
+                    "{}: {}",
+                    env!("VERGEN_BUILD_TIMESTAMP"),
+                    env!("VERGEN_GIT_DESCRIBE")
+                ),
+            },
+        ));
 
         let bs =
             Bytes::from(bincode::serialize(&resp).expect("diagnostics response serialization"));
@@ -392,7 +399,7 @@ impl Reading for P2P {
                     self.process_diagnostics_request(source, kind).await?;
                 }
                 // Nodes are expected to ignore the diagnostics response.
-                protocol::MessageV0::DiagnosticsResponse(_) => (),
+                protocol::MessageV0::DiagnosticsResponse(_, _) => (),
             },
             Err(err) => tracing::error!("failed to decode incoming transaction: {}", err),
         }
@@ -464,6 +471,7 @@ mod tests {
             name,
             "127.0.0.1:0".parse().unwrap(),
             "secret passphrase",
+            PublicKey::from_secret_key(&SecretKey::default()),
             None,
             None,
             http_peer_list1,

crates/node/src/networking/p2p/protocol.rs

@@ -1,6 +1,7 @@
 use std::{collections::BTreeSet, net::SocketAddr};
 
 use gevulot_node::types;
+use libsecp256k1::PublicKey;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -25,7 +26,7 @@ pub(crate) enum Message {
 pub(crate) enum MessageV0 {
     Transaction(types::Transaction<types::transaction::Validated>),
     DiagnosticsRequest(DiagnosticsRequestKind),
-    DiagnosticsResponse(DiagnosticsResponseV0),
+    DiagnosticsResponse(PublicKey, DiagnosticsResponseV0),
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]