Remove set_finality_proof_request_builder (#3087)

* Remove set_finality_proof_request_builder

* Fix Babe

* Fix Grandpa

* Fix service doctests

substrate/core/consensus/common/src/block_import.rs

@@ -247,9 +247,3 @@ pub trait FinalityProofImport<B: BlockT> {
 		verifier: &dyn Verifier<B>,
 	) -> Result<(B::Hash, NumberFor<B>), Self::Error>;
 }
-
-/// Finality proof request builder.
-pub trait FinalityProofRequestBuilder<B: BlockT>: Send {
-	/// Build data blob, associated with the request.
-	fn build_request_data(&mut self, hash: &B::Hash) -> Vec<u8>;
-}

substrate/core/consensus/common/src/import_queue.rs

@@ -30,7 +30,7 @@ use runtime_primitives::{Justification, traits::{Block as BlockT, Header as _, N
 use crate::{error::Error as ConsensusError, well_known_cache_keys::Id as CacheKeyId};
 use crate::block_import::{
 	BlockImport, BlockOrigin, ImportBlock, ImportedAux, JustificationImport, ImportResult,
-	FinalityProofImport, FinalityProofRequestBuilder,
+	FinalityProofImport,
 };
 
 pub use basic_queue::BasicQueue;
@@ -47,9 +47,6 @@ pub type BoxJustificationImport<B> = Box<dyn JustificationImport<B, Error=Consen
 /// Shared finality proof import struct used by the queue.
 pub type BoxFinalityProofImport<B> = Box<dyn FinalityProofImport<B, Error=ConsensusError> + Send + Sync>;
 
-/// Shared finality proof request builder struct used by the queue.
-pub type BoxFinalityProofRequestBuilder<B> = Box<dyn FinalityProofRequestBuilder<B> + Send + Sync>;
-
 /// Maps to the Origin used by the network.
 pub type Origin = libp2p::PeerId;
 
@@ -139,8 +136,6 @@ pub trait Link<B: BlockT>: Send {
 	) {}
 	/// Request a finality proof for the given block.
 	fn request_finality_proof(&mut self, _hash: &B::Hash, _number: NumberFor<B>) {}
-	/// Remember finality proof request builder on start.
-	fn set_finality_proof_request_builder(&mut self, _request_builder: BoxFinalityProofRequestBuilder<B>) {}
 	/// Adjusts the reputation of the given peer.
 	fn report_peer(&mut self, _who: Origin, _reputation_change: i32) {}
 	/// Restart sync.

substrate/core/consensus/common/src/import_queue/basic_queue.rs

@@ -22,7 +22,7 @@ use crate::error::Error as ConsensusError;
 use crate::block_import::{BlockImport, BlockOrigin};
 use crate::import_queue::{
 	BlockImportResult, BlockImportError, Verifier, BoxBlockImport, BoxFinalityProofImport,
-	BoxFinalityProofRequestBuilder, BoxJustificationImport, ImportQueue, Link, Origin,
+	BoxJustificationImport, ImportQueue, Link, Origin,
 	IncomingBlock, import_single_block,
 	buffered_link::{self, BufferedLinkSender, BufferedLinkReceiver}
 };
@@ -43,8 +43,6 @@ pub struct BasicQueue<B: BlockT> {
 	sender: mpsc::UnboundedSender<ToWorkerMsg<B>>,
 	/// Results coming from the worker task.
 	result_port: BufferedLinkReceiver<B>,
-	/// Sent through the link as soon as possible.
-	finality_proof_request_builder: Option<BoxFinalityProofRequestBuilder<B>>,
 	/// Since we have to be in a tokio context in order to spawn background tasks, we first store
 	/// the task to spawn here, then extract it as soon as we are in a tokio context.
 	/// If `Some`, contains the task to spawn in the background. If `None`, the future has already
@@ -66,7 +64,6 @@ impl<B: BlockT> BasicQueue<B> {
 		block_import: BoxBlockImport<B>,
 		justification_import: Option<BoxJustificationImport<B>>,
 		finality_proof_import: Option<BoxFinalityProofImport<B>>,
-		finality_proof_request_builder: Option<BoxFinalityProofRequestBuilder<B>>,
 	) -> Self {
 		let (result_sender, result_port) = buffered_link::buffered_link();
 		let (future, worker_sender) = BlockImportWorker::new(
@@ -80,7 +77,6 @@ impl<B: BlockT> BasicQueue<B> {
 		Self {
 			sender: worker_sender,
 			result_port,
-			finality_proof_request_builder,
 			future_to_spawn: Some(Box::new(future)),
 			manual_poll: None,
 		}
@@ -130,10 +126,6 @@ impl<B: BlockT> ImportQueue<B> for BasicQueue<B> {
 			}
 		}
 
-		if let Some(fprb) = self.finality_proof_request_builder.take() {
-			link.set_finality_proof_request_builder(fprb);
-		}
-
 		self.result_port.poll_actions(link);
 	}
 }

substrate/core/consensus/common/src/import_queue/buffered_link.rs

@@ -34,7 +34,7 @@
 
 use futures::{prelude::*, sync::mpsc};
 use runtime_primitives::traits::{Block as BlockT, NumberFor};
-use crate::import_queue::{Origin, Link, BoxFinalityProofRequestBuilder};
+use crate::import_queue::{Origin, Link};
 
 /// Wraps around an unbounded channel from the `futures` crate. The sender implements `Link` and
 /// can be used to buffer commands, and the receiver can be used to poll said commands and transfer
@@ -60,7 +60,6 @@ enum BlockImportWorkerMsg<B: BlockT> {
 	RequestJustification(B::Hash, NumberFor<B>),
 	FinalityProofImported(Origin, (B::Hash, NumberFor<B>), Result<(B::Hash, NumberFor<B>), ()>),
 	RequestFinalityProof(B::Hash, NumberFor<B>),
-	SetFinalityProofRequestBuilder(BoxFinalityProofRequestBuilder<B>),
 	ReportPeer(Origin, i32),
 	Restart,
 }
@@ -107,10 +106,6 @@ impl<B: BlockT> Link<B> for BufferedLinkSender<B> {
 		let _ = self.tx.unbounded_send(BlockImportWorkerMsg::RequestFinalityProof(hash.clone(), number));
 	}
 
-	fn set_finality_proof_request_builder(&mut self, request_builder: BoxFinalityProofRequestBuilder<B>) {
-		let _ = self.tx.unbounded_send(BlockImportWorkerMsg::SetFinalityProofRequestBuilder(request_builder));
-	}
-
 	fn report_peer(&mut self, who: Origin, reputation_change: i32) {
 		let _ = self.tx.unbounded_send(BlockImportWorkerMsg::ReportPeer(who, reputation_change));
 	}
@@ -155,8 +150,6 @@ impl<B: BlockT> BufferedLinkReceiver<B> {
 					link.finality_proof_imported(who, block, result),
 				BlockImportWorkerMsg::RequestFinalityProof(hash, number) =>
 					link.request_finality_proof(&hash, number),
-				BlockImportWorkerMsg::SetFinalityProofRequestBuilder(builder) =>
-					link.set_finality_proof_request_builder(builder),
 				BlockImportWorkerMsg::ReportPeer(who, reput) =>
 					link.report_peer(who, reput),
 				BlockImportWorkerMsg::Restart =>

substrate/core/consensus/common/src/lib.rs

@@ -48,7 +48,7 @@ const MAX_BLOCK_SIZE: usize = 4 * 1024 * 1024 + 512;
 pub use self::error::Error;
 pub use block_import::{
 	BlockImport, BlockOrigin, ForkChoiceStrategy, ImportedAux, ImportBlock, ImportResult,
-	JustificationImport, FinalityProofImport, FinalityProofRequestBuilder,
+	JustificationImport, FinalityProofImport,
 };
 pub use select_chain::SelectChain;