Remove block clone (#1448)

## Issue Addressed

#1028 

A bit late, but I think if `BlockError` had a kind (the current `BlockError` minus everything on the variants that comes directly from the block) and the original block, more clones could be removed

beacon_node/network/src/router/mod.rs

@@ -240,13 +240,15 @@ impl<T: BeaconChainTypes> Router<T> {
                 }
             }
             PubsubMessage::BeaconBlock(block) => {
-                match self.processor.should_forward_block(&peer_id, block) {
+                match self.processor.should_forward_block(block) {
                     Ok(verified_block) => {
                         info!(self.log, "New block received"; "slot" => verified_block.block.slot(), "hash" => verified_block.block_root.to_string());
                         self.propagate_message(id, peer_id.clone());
                         self.processor.on_block_gossip(peer_id, verified_block);
                     }
-                    Err(BlockError::ParentUnknown { .. }) => {} // performing a parent lookup
+                    Err(BlockError::ParentUnknown(block)) => {
+                        self.processor.on_unknown_parent(peer_id, block);
+                    }
                     Err(e) => {
                         // performing a parent lookup
                         warn!(self.log, "Could not verify block for gossip";
@@ -260,7 +262,7 @@ impl<T: BeaconChainTypes> Router<T> {
                     .processor
                     .verify_voluntary_exit_for_gossip(&peer_id, *exit)
                 {
-                    self.propagate_message(id, peer_id.clone());
+                    self.propagate_message(id, peer_id);
                     self.processor.import_verified_voluntary_exit(verified_exit);
                 }
             }
@@ -274,7 +276,7 @@ impl<T: BeaconChainTypes> Router<T> {
                     .processor
                     .verify_proposer_slashing_for_gossip(&peer_id, *proposer_slashing)
                 {
-                    self.propagate_message(id, peer_id.clone());
+                    self.propagate_message(id, peer_id);
                     self.processor
                         .import_verified_proposer_slashing(verified_proposer_slashing);
                 }
@@ -289,7 +291,7 @@ impl<T: BeaconChainTypes> Router<T> {
                     .processor
                     .verify_attester_slashing_for_gossip(&peer_id, *attester_slashing)
                 {
-                    self.propagate_message(id, peer_id.clone());
+                    self.propagate_message(id, peer_id);
                     self.processor
                         .import_verified_attester_slashing(verified_attester_slashing);
                 }

beacon_node/network/src/router/processor.rs

@@ -503,17 +503,17 @@ impl<T: BeaconChainTypes> Processor<T> {
     /// across the network.
     pub fn should_forward_block(
         &mut self,
-        peer_id: &PeerId,
         block: Box<SignedBeaconBlock<T::EthSpec>>,
-    ) -> Result<GossipVerifiedBlock<T>, BlockError> {
-        let result = self.chain.verify_block_for_gossip(*block.clone());
+    ) -> Result<GossipVerifiedBlock<T>, BlockError<T::EthSpec>> {
+        self.chain.verify_block_for_gossip(*block)
+    }
 
-        if let Err(BlockError::ParentUnknown(_)) = result {
-            // if we don't know the parent, start a parent lookup
-            // TODO: Modify the return to avoid the block clone.
-            self.send_to_sync(SyncMessage::UnknownBlock(peer_id.clone(), block));
-        }
-        result
+    pub fn on_unknown_parent(
+        &mut self,
+        peer_id: PeerId,
+        block: Box<SignedBeaconBlock<T::EthSpec>>,
+    ) {
+        self.send_to_sync(SyncMessage::UnknownBlock(peer_id, block));
     }
 
     /// Process a gossip message declaring a new block.

beacon_node/network/src/sync/block_processor.rs

@@ -6,7 +6,7 @@ use eth2_libp2p::PeerId;
 use slog::{debug, error, trace, warn};
 use std::sync::{Arc, Weak};
 use tokio::sync::mpsc;
-use types::SignedBeaconBlock;
+use types::{EthSpec, SignedBeaconBlock};
 
 /// Id associated to a block processing request, either a batch or a single block.
 #[derive(Clone, Debug, PartialEq)]
@@ -178,12 +178,18 @@ fn run_fork_choice<T: BeaconChainTypes>(chain: Arc<BeaconChain<T>>, log: &slog::
 }
 
 /// Helper function to handle a `BlockError` from `process_chain_segment`
-fn handle_failed_chain_segment(error: BlockError, log: &slog::Logger) -> Result<(), String> {
+fn handle_failed_chain_segment<T: EthSpec>(
+    error: BlockError<T>,
+    log: &slog::Logger,
+) -> Result<(), String> {
     match error {
-        BlockError::ParentUnknown(parent) => {
+        BlockError::ParentUnknown(block) => {
             // blocks should be sequential and all parents should exist
 
-            Err(format!("Block has an unknown parent: {}", parent))
+            Err(format!(
+                "Block has an unknown parent: {}",
+                block.parent_root()
+            ))
         }
         BlockError::BlockIsAlreadyKnown => {
             // This can happen for many reasons. Head sync's can download multiples and parent