impl Display for NodeID + From<SigningKey> for SecretKey

jormungandr-lib/src/crypto/key.rs

@@ -414,6 +414,12 @@ impl<A: AsymmetricKey> From<SecretKey<A>> for SigningKey<A> {
     }
 }
 
+impl<A: AsymmetricKey> From<SigningKey<A>> for SecretKey<A> {
+    fn from(key: SigningKey<A>) -> Self {
+        key.0
+    }
+}
+
 impl<A: AsymmetricPublicKey> From<PublicKey<A>> for Identifier<A> {
     fn from(key: PublicKey<A>) -> Self {
         Identifier(key)

jormungandr/src/blockchain/process.rs

@@ -243,7 +243,7 @@ impl Process {
                     hash = %header.hash(),
                     parent = %header.parent_id(),
                     date = %header.block_date(),
-                    peer = ?node_id
+                    %node_id
                 );
                 let _enter = span.enter();
                 tracing::debug!("received block announcement from network");

jormungandr/src/network/client/connect.rs

@@ -55,7 +55,7 @@ pub fn connect(state: ConnectionState, channels: Channels) -> (ConnectHandle, Co
         //TODO: check id is the expected one
         let peer_id = validate_peer_auth(hr.auth, &nonce)?;
 
-        tracing::debug!(node_id = ?peer_id, "authenticated server peer node");
+        tracing::debug!(node_id = %peer_id, "authenticated server peer node");
 
         // Send client authentication
         let auth = keypair.sign(&hr.nonce);

jormungandr/src/network/client/mod.rs

@@ -11,7 +11,7 @@ use super::{
         comm::{OutboundSubscription, PeerComms},
         Address,
     },
-    subscription::{BlockAnnouncementProcessor, FragmentProcessor, GossipProcessor},
+    subscription::{BlockAnnouncementProcessor, Direction, FragmentProcessor, GossipProcessor},
     Channels, GlobalStateR,
 };
 use crate::{
@@ -84,6 +84,7 @@ impl Client {
             builder.channels.topology_box,
             inbound.peer_id,
             global_state.clone(),
+            Direction::Client,
         );
 
         Client {
@@ -153,7 +154,7 @@ impl Progress {
 }
 
 impl Client {
-    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = ?self.inbound.peer_id))]
+    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = %self.inbound.peer_id))]
     fn process_block_event(&mut self, cx: &mut Context<'_>) -> Poll<Result<ProcessingOutcome, ()>> {
         use self::ProcessingOutcome::*;
         // Drive sending of a message to block task to clear the buffered
@@ -244,7 +245,7 @@ impl Client {
         Ok(Continue).into()
     }
 
-    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = ?self.inbound.peer_id))]
+    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = %self.inbound.peer_id))]
     fn upload_blocks(&mut self, block_ids: BlockIds) -> Result<(), ()> {
         if block_ids.is_empty() {
             tracing::info!("peer has sent an empty block solicitation");
@@ -294,7 +295,7 @@ impl Client {
         Ok(())
     }
 
-    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = ?self.inbound.peer_id))]
+    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = %self.inbound.peer_id))]
     fn push_missing_headers(&mut self, req: ChainPullRequest) -> Result<(), ()> {
         let from = req.from.decode().map_err(|e| {
             tracing::info!(
@@ -346,7 +347,7 @@ impl Client {
         Ok(())
     }
 
-    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = ?self.inbound.peer_id))]
+    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = %self.inbound.peer_id))]
     fn pull_headers(&mut self, req: ChainPullRequest) {
         let mut block_box = self.block_sink.message_box();
 
@@ -392,7 +393,7 @@ impl Client {
         );
     }
 
-    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = ?self.inbound.peer_id))]
+    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = %self.inbound.peer_id))]
     fn solicit_blocks(&mut self, block_ids: BlockIds) {
         let mut block_box = self.block_sink.message_box();
         let (handle, sink, _) = intercom::stream_request(buffer_sizes::inbound::BLOCKS);
@@ -437,7 +438,7 @@ impl Client {
         );
     }
 
-    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = ?self.inbound.peer_id, direction = "in"))]
+    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = %self.inbound.peer_id, direction = "in"))]
     fn process_fragments(&mut self, cx: &mut Context<'_>) -> Poll<Result<ProcessingOutcome, ()>> {
         use self::ProcessingOutcome::*;
         let mut fragment_sink = Pin::new(&mut self.fragment_sink);
@@ -471,7 +472,7 @@ impl Client {
         }
     }
 
-    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = ?self.inbound.peer_id, direction = "in"))]
+    #[instrument(skip_all, level = "debug", fields(peer_addr = %self.inbound.peer_addr, id = %self.inbound.peer_id, direction = "in"))]
     fn process_gossip(&mut self, cx: &mut Context<'_>) -> Poll<Result<ProcessingOutcome, ()>> {
         use self::ProcessingOutcome::*;
         let mut gossip_sink = Pin::new(&mut self.gossip_sink);

jormungandr/src/network/mod.rs

@@ -16,8 +16,6 @@ mod subscription;
 use self::convert::Encode;
 
 use futures::{future, prelude::*};
-use rand::{Rng, SeedableRng};
-use rand_chacha::ChaChaRng;
 use thiserror::Error;
 use tokio_util::sync::CancellationToken;
 
@@ -172,12 +170,9 @@ impl GlobalState {
     ) -> Self {
         let peers = Peers::new(config.max_connections);
 
-        let mut rng_seed = [0; 32];
-        rand::thread_rng().fill(&mut rng_seed);
-        let mut prng = ChaChaRng::from_seed(rng_seed);
-
         //TODO: move this to a secure enclave
-        let keypair = NodeKeyPair::from(config.node_key);
+        let keypair =
+            NodeKeyPair::from(<chain_crypto::SecretKey<_>>::from(config.node_key.clone()));
 
         GlobalState {
             block0_hash,
@@ -368,7 +363,7 @@ where
     let mut res = Vec::new();
     for peer in peers {
         if f(peer.id(), arg.clone())
-            .instrument(span!(Level::DEBUG, "p2p_comm", peer = %peer.address(), id = ?peer.id()))
+            .instrument(span!(Level::DEBUG, "p2p_comm", peer = %peer.address(), id = %peer.id()))
             .await
             .is_err()
         {
@@ -469,14 +464,14 @@ fn connect_and_propagate(
     let _enter = state.span.enter();
     options.evict_clients = state.num_clients_to_bump();
     if let Some(self_addr) = state.node_address() {
-        if node_addr == self_addr {
-            tracing::error!(peer = %node_addr, "topology tells the node to connect to itself, ignoring");
+        if addr == self_addr {
+            tracing::error!(peer = %addr, "topology tells the node to connect to itself, ignoring");
             return;
         }
     }
     drop(_enter);
-    let peer = Peer::new(node_addr);
-    let conn_span = span!(parent: &state.span, Level::DEBUG, "client", addr = %node_addr);
+    let peer = Peer::new(addr);
+    let conn_span = span!(parent: &state.span, Level::DEBUG, "client", addr = %addr);
     let spawn_state = state.clone();
     let cf = async move {
         let conn_state = ConnectionState::new(state.clone(), &peer, Span::current());
@@ -506,24 +501,24 @@ fn connect_and_propagate(
                 if !benign {
                     channels
                         .topology_box
-                        .send(TopologyMsg::DemotePeer(node_id))
+                        .send(TopologyMsg::DemotePeer(id))
                         .await
                         .unwrap_or_else(|e| {
                             tracing::error!("Error sending message to topology task: {}", e)
                         });
-                    state.peers.remove_peer(&node_id).await;
+                    state.peers.remove_peer(&id).await;
                 }
             }
             Ok(client) => {
                 // This enforce processing any pending operation that could
                 // have been scheduled on this peer
-                state.peers.update_entry(node_id).await;
+                state.peers.update_entry(id).await;
 
                 state.inc_client_count();
 
                 channels
                     .topology_box
-                    .send(TopologyMsg::PromotePeer(node_id))
+                    .send(TopologyMsg::PromotePeer(id))
                     .await
                     .unwrap_or_else(|e| {
                         tracing::error!("Error sending message to topology task: {}", e)

jormungandr/src/network/p2p/comm.rs

@@ -524,7 +524,7 @@ impl Peers {
     pub async fn server_complete_handshake(&self, peer_addr: Address, id: NodeId) {
         tracing::debug!(
             peer_addr = %peer_addr,
-            node_id = ?id,
+            node_id = %id,
             "authenticated client peer node"
         );
         let mut map = self.inner().await;
@@ -533,7 +533,7 @@ impl Peers {
         } else {
             tracing::warn!(
                 %peer_addr,
-                ?id,
+                %id,
                 "peer is not known to the node, was the handshake procedure skipped?",
             );
         }
@@ -690,7 +690,7 @@ impl Peers {
     pub async fn solicit_blocks_peer(&self, peer: &NodeId, hashes: BlockIds) {
         let span = debug_span!(
             "block solicitation",
-            ?peer,
+            %peer,
             peer_addr = tracing::field::Empty,
             hashes = %format!("[{}]", hashes.iter().map(hex::encode).collect::<Vec<_>>().join(", "))
         );
@@ -724,7 +724,7 @@ impl Peers {
     pub async fn pull_headers(&self, peer: &NodeId, from: BlockIds, to: BlockId) {
         let span = debug_span!(
             "pull_header",
-            ?peer,
+            %peer,
             peer_addr = tracing::field::Empty,
             from = %format!("[{}]", from.iter().map(hex::encode).collect::<Vec<_>>().join(", ")),
             to = %hex::encode(to)
@@ -749,7 +749,7 @@ impl Peers {
                 None => {
                     // TODO: connect and request on demand, or select another peer?
                     tracing::info!(
-                        peer = ?peer,
+                        peer = %peer,
                         "peer not available to pull headers from"
                     );
                 }

jormungandr/src/topology/mod.rs

@@ -7,6 +7,7 @@ use jormungandr_lib::time::SystemTime;
 use serde::Serialize;
 use serde::Serializer;
 use std::convert::{TryFrom, TryInto};
+use std::fmt;
 use std::hash::{Hash, Hasher};
 
 mod gossip;
@@ -75,6 +76,12 @@ impl TryFrom<&[u8]> for NodeId {
     }
 }
 
+impl fmt::Display for NodeId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 impl AsRef<keynesis::key::ed25519::PublicKey> for NodeId {
     fn as_ref(&self) -> &keynesis::key::ed25519::PublicKey {
         &self.0

jormungandr/src/topology/quarantine.rs

@@ -76,16 +76,16 @@ impl ReportRecords {
         if self.report_whitelist.contains(&node.address()) {
             tracing::debug!(
                 node = %node.address(),
-                id=?node.id(),
+                id=%node.id(),
                 "quarantine whitelists prevents this node from being reported",
             );
             ReportNodeStatus::Ok
         } else if self.report_grace.contains(&node.id()) {
-            tracing::trace!(node = %node.address(), id=?node.id(), "not reporting node in grace list");
+            tracing::trace!(node = %node.address(), id=%node.id(), "not reporting node in grace list");
             ReportNodeStatus::Ok
         } else {
             let mut peer_info = PeerInfo::from(node);
-            tracing::debug!(node = %peer_info.address, id=?peer_info.id, ?self.report_duration, "reporting node");
+            tracing::debug!(node = %peer_info.address, id=%peer_info.id, ?self.report_duration, "reporting node");
             // If we'll handle report reasons other that a connectivity issue in the future, we may want to
             // demote a peer all the way down to dirty in case of a serious violation.
             topology.remove_peer(peer_info.id.as_ref());
@@ -102,7 +102,7 @@ impl ReportRecords {
             // nodes again after some time if we haven't heard from them sooner (and avoid network splits).
             if topology.peers().dirty().contains(peer_info.id.as_ref()) {
                 peer_info.quarantined = Some(SystemTime::now().into());
-                tracing::debug!(node = %peer_info.address, id=?peer_info.id, "node has been quarantined");
+                tracing::debug!(node = %peer_info.address, id=%peer_info.id, "node has been quarantined");
                 result = ReportNodeStatus::Quarantine;
             }
 

jormungandr/src/topology/topology.rs

@@ -209,7 +209,7 @@ impl P2pTopology {
     }
 
     /// register a strike against the given peer
-    #[instrument(skip(self), level = "debug")]
+    #[instrument(skip_all, level = "debug", fields(%node_id))]
     pub fn report_node(&mut self, node_id: &NodeId) {
         if let Some(node) = self.topology.get(node_id.as_ref()).cloned() {
             let result = self