Account manager, bootnodes, RPC display and sync fixes

beacon_node/eth2-libp2p/src/discovery.rs

@@ -114,7 +114,7 @@ impl<TSubstream> Discovery<TSubstream> {
         self.find_peers();
     }
 
-    /// Add an Enr to the routing table of the discovery mechanism.
+    /// Add an ENR to the routing table of the discovery mechanism.
     pub fn add_enr(&mut self, enr: Enr) {
         self.discovery.add_enr(enr);
     }

beacon_node/eth2-libp2p/src/rpc/methods.rs

@@ -157,3 +157,51 @@ impl ErrorMessage {
         String::from_utf8(self.error_message.clone()).unwrap_or_else(|_| "".into())
     }
 }
+
+impl std::fmt::Display for HelloMessage {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Hello Message: Fork Version: {:?}, Finalized Root: {}, Finalized Epoch: {}, Head Root: {}, Head Slot: {}", self.fork_version, self.finalized_root, self.finalized_epoch, self.head_root, self.head_slot)
+    }
+}
+
+impl std::fmt::Display for RPCResponse {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RPCResponse::Hello(hello) => write!(f, "{}", hello),
+            RPCResponse::BeaconBlocks(_) => write!(f, "<BeaconBlocks>"),
+            RPCResponse::RecentBeaconBlocks(_) => write!(f, "<RecentBeaconBlocks>"),
+        }
+    }
+}
+
+impl std::fmt::Display for RPCErrorResponse {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RPCErrorResponse::Success(res) => write!(f, "{}", res),
+            RPCErrorResponse::InvalidRequest(err) => write!(f, "Invalid Request: {:?}", err),
+            RPCErrorResponse::ServerError(err) => write!(f, "Server Error: {:?}", err),
+            RPCErrorResponse::Unknown(err) => write!(f, "Unknown Error: {:?}", err),
+        }
+    }
+}
+
+impl std::fmt::Display for GoodbyeReason {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GoodbyeReason::ClientShutdown => write!(f, "Client Shutdown"),
+            GoodbyeReason::IrrelevantNetwork => write!(f, "Irrelevant Network"),
+            GoodbyeReason::Fault => write!(f, "Fault"),
+            GoodbyeReason::Unknown => write!(f, "Unknown Reason"),
+        }
+    }
+}
+
+impl std::fmt::Display for BeaconBlocksRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Head Block Root: {},  Start Slot: {}, Count: {}, Step: {}",
+            self.head_block_root, self.start_slot, self.count, self.step
+        )
+    }
+}

beacon_node/eth2-libp2p/src/rpc/mod.rs

@@ -47,6 +47,16 @@ impl RPCEvent {
     }
 }
 
+impl std::fmt::Display for RPCEvent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RPCEvent::Request(id, req) => write!(f, "RPC Request(Id: {}, {})", id, req),
+            RPCEvent::Response(id, res) => write!(f, "RPC Response(Id: {}, {})", id, res),
+            RPCEvent::Error(id, err) => write!(f, "RPC Request(Id: {}, Error: {:?})", id, err),
+        }
+    }
+}
+
 /// Implements the libp2p `NetworkBehaviour` trait and therefore manages network-level
 /// logic.
 pub struct RPC<TSubstream> {

beacon_node/eth2-libp2p/src/rpc/protocol.rs

@@ -288,3 +288,14 @@ impl std::error::Error for RPCError {
         }
     }
 }
+
+impl std::fmt::Display for RPCRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RPCRequest::Hello(hello) => write!(f, "Hello Message: {}", hello),
+            RPCRequest::Goodbye(reason) => write!(f, "Goodbye: {}", reason),
+            RPCRequest::BeaconBlocks(req) => write!(f, "Beacon Blocks: {}", req),
+            RPCRequest::RecentBeaconBlocks(req) => write!(f, "Recent Beacon Blocks: {:?}", req),
+        }
+    }
+}

beacon_node/eth2-libp2p/src/service.rs

@@ -79,8 +79,8 @@ impl Service {
             }
         };
 
-        // attempt to connect to user-input libp2p nodes
-        for multiaddr in config.libp2p_nodes {
+        // helper closure for dialing peers
+        let mut dial_addr = |multiaddr: Multiaddr| {
             match Swarm::dial_addr(&mut swarm, multiaddr.clone()) {
                 Ok(()) => debug!(log, "Dialing libp2p peer"; "address" => format!("{}", multiaddr)),
                 Err(err) => debug!(
@@ -88,6 +88,18 @@ impl Service {
                     "Could not connect to peer"; "address" => format!("{}", multiaddr), "error" => format!("{:?}", err)
                 ),
             };
+        };
+
+        // attempt to connect to user-input libp2p nodes
+        for multiaddr in config.libp2p_nodes {
+            dial_addr(multiaddr);
+        }
+
+        // attempt to connect to any specified boot-nodes
+        for bootnode_enr in config.boot_nodes {
+            for multiaddr in bootnode_enr.multiaddr() {
+                dial_addr(multiaddr);
+            }
         }
 
         // subscribe to default gossipsub topics