Add block announce validator.

core/client/src/backend.rs

@@ -42,6 +42,7 @@ pub(crate) struct ImportSummary<Block: BlockT> {
 	pub(crate) is_new_best: bool,
 	pub(crate) storage_changes: Option<(StorageCollection, ChildStorageCollection)>,
 	pub(crate) retracted: Vec<Block::Hash>,
+	pub(crate) associated_data: Vec<u8>,
 }
 
 /// Import operation wrapper
@@ -144,7 +145,7 @@ pub trait Finalizer<Block: BlockT, H: Hasher<Out=Block::Hash>, B: Backend<Block,
 		notify: bool,
 	) -> error::Result<()>;
 
-		
+
 	/// Finalize a block. This will implicitly finalize all blocks up to it and
 	/// fire finality notifications.
 	///

core/client/src/client.rs

@@ -49,7 +49,7 @@ use state_machine::{
 };
 use executor::{RuntimeVersion, RuntimeInfo};
 use consensus::{
-	Error as ConsensusError, BlockImportParams,
+	Error as ConsensusError, BlockStatus, BlockImportParams,
 	ImportResult, BlockOrigin, ForkChoiceStrategy,
 	well_known_cache_keys::Id as CacheKeyId,
 	SelectChain, self,
@@ -173,21 +173,6 @@ pub struct ClientInfo<Block: BlockT> {
 	pub used_state_cache_size: Option<usize>,
 }
 
-/// Block status.
-#[derive(Debug, PartialEq, Eq)]
-pub enum BlockStatus {
-	/// Added to the import queue.
-	Queued,
-	/// Already in the blockchain and the state is available.
-	InChainWithState,
-	/// In the blockchain, but the state is not available.
-	InChainPruned,
-	/// Block or parent is known to be bad.
-	KnownBad,
-	/// Not in the queue or the blockchain.
-	Unknown,
-}
-
 /// Summary of an imported block
 #[derive(Clone, Debug)]
 pub struct BlockImportNotification<Block: BlockT> {
@@ -201,6 +186,8 @@ pub struct BlockImportNotification<Block: BlockT> {
 	pub is_new_best: bool,
 	/// List of retracted blocks ordered by block number.
 	pub retracted: Vec<Block::Hash>,
+	/// Any data associated with this block import.
+	pub associated_data: Vec<u8>,
 }
 
 /// Summary of a finalized block.
@@ -1015,6 +1002,7 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 				is_new_best,
 				storage_changes,
 				retracted,
+				associated_data: Vec::new(), // TODO
 			})
 		}
 
@@ -1185,10 +1173,7 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 		Ok(())
 	}
 
-	fn notify_imported(
-		&self,
-		notify_import: ImportSummary<Block>,
-	) -> error::Result<()> {
+	fn notify_imported(&self, notify_import: ImportSummary<Block>) -> error::Result<()> {
 		if let Some(storage_changes) = notify_import.storage_changes {
 			// TODO [ToDr] How to handle re-orgs? Should we re-emit all storage changes?
 			self.storage_notifications.lock()
@@ -1205,6 +1190,7 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 			header: notify_import.header,
 			is_new_best: notify_import.is_new_best,
 			retracted: notify_import.retracted,
+			associated_data: notify_import.associated_data,
 		};
 
 		self.import_notification_sinks.lock()
@@ -1939,6 +1925,16 @@ pub mod utils {
 	}
 }
 
+impl<BE, E, B, RA> consensus::block_validation::Chain<B> for Client<BE, E, B, RA>
+	where BE: backend::Backend<B, Blake2Hasher>,
+		  E: CallExecutor<B, Blake2Hasher>,
+		  B: BlockT<Hash = H256>
+{
+	fn block_status(&self, id: &BlockId<B>) -> Result<BlockStatus, Box<dyn std::error::Error + Send>> {
+		Client::block_status(self, id).map_err(|e| Box::new(e) as Box<_>)
+	}
+}
+
 #[cfg(test)]
 pub(crate) mod tests {
 	use std::collections::HashMap;

core/client/src/lib.rs

@@ -113,7 +113,7 @@ pub use crate::call_executor::{CallExecutor, LocalCallExecutor};
 pub use crate::client::{
 	new_with_backend,
 	new_in_mem,
-	BlockBody, BlockStatus, ImportNotifications, FinalityNotifications, BlockchainEvents,
+	BlockBody, ImportNotifications, FinalityNotifications, BlockchainEvents,
 	BlockImportNotification, Client, ClientInfo, ExecutionStrategies, FinalityNotification,
 	LongestChain, BlockOf, ProvideUncles,
 	utils, apply_aux,

core/consensus/common/src/block_validation.rs

@@ -0,0 +1,66 @@
+// Copyright 2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+//
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Block announcement validation.
+
+use crate::BlockStatus;
+use sr_primitives::{generic::BlockId, traits::Block};
+use std::{error::Error, sync::Arc};
+
+/// A type which provides access to chain information.
+pub trait Chain<B: Block> {
+	/// Retrieve the status of the block denoted by the given [`BlockId`].
+	fn block_status(&self, id: &BlockId<B>) -> Result<BlockStatus, Box<dyn Error + Send>>;
+}
+
+impl<T: Chain<B>, B: Block> Chain<B> for Arc<T> {
+	fn block_status(&self, id: &BlockId<B>) -> Result<BlockStatus, Box<dyn Error + Send>> {
+		(&**self).block_status(id)
+	}
+}
+
+/// Result of `BlockAnnounceValidator::validate`.
+#[derive(Debug, PartialEq, Eq)]
+pub enum Validation {
+	/// Valid block announcement.
+	Success,
+	/// Invalid block announcement.
+	Failure,
+}
+
+/// Type which checks incoming block announcements.
+pub trait BlockAnnounceValidator<B: Block> {
+	/// Validate the announced header and its associated data.
+	fn validate(&mut self, header: &B::Header, data: &[u8]) -> Result<Validation, Box<dyn Error + Send>>;
+}
+
+/// Default implementation of `BlockAnnounceValidator`.
+#[derive(Debug)]
+pub struct DefaultBlockAnnounceValidator<C> {
+	chain: C
+}
+
+impl<C> DefaultBlockAnnounceValidator<C> {
+	pub fn new(chain: C) -> Self {
+		Self { chain }
+	}
+}
+
+impl<B: Block, C: Chain<B>> BlockAnnounceValidator<B> for DefaultBlockAnnounceValidator<C> {
+	fn validate(&mut self, _h: &B::Header, _d: &[u8]) -> Result<Validation, Box<dyn Error + Send>> {
+		Ok(Validation::Success)
+	}
+}

core/consensus/common/src/lib.rs

@@ -35,6 +35,7 @@ use sr_primitives::traits::{Block as BlockT, DigestFor};
 use futures::prelude::*;
 pub use inherents::InherentData;
 
+pub mod block_validation;
 pub mod offline_tracker;
 pub mod error;
 pub mod block_import;
@@ -52,6 +53,21 @@ pub use block_import::{
 };
 pub use select_chain::SelectChain;
 
+/// Block status.
+#[derive(Debug, PartialEq, Eq)]
+pub enum BlockStatus {
+	/// Added to the import queue.
+	Queued,
+	/// Already in the blockchain and the state is available.
+	InChainWithState,
+	/// In the blockchain, but the state is not available.
+	InChainPruned,
+	/// Block or parent is known to be bad.
+	KnownBad,
+	/// Not in the queue or the blockchain.
+	Unknown,
+}
+
 /// Environment producer for a Consensus instance. Creates proposer instance and communication streams.
 pub trait Environment<B: BlockT> {
 	/// The proposer type this creates.

core/finality-grandpa/src/communication/mod.rs

@@ -127,7 +127,7 @@ pub trait Network<Block: BlockT>: Clone + Send + 'static {
 	fn report(&self, who: network::PeerId, cost_benefit: i32);
 
 	/// Inform peers that a block with given hash should be downloaded.
-	fn announce(&self, block: Block::Hash);
+	fn announce(&self, block: Block::Hash, associated_data: Vec<u8>);
 }
 
 /// Create a unique topic for a round and set-id combo.
@@ -197,8 +197,8 @@ impl<B, S, H> Network<B> for Arc<NetworkService<B, S, H>> where
 		self.report_peer(who, cost_benefit)
 	}
 
-	fn announce(&self, block: B::Hash) {
-		self.announce_block(block)
+	fn announce(&self, block: B::Hash, associated_data: Vec<u8>) {
+		self.announce_block(block, associated_data)
 	}
 }
 
@@ -721,7 +721,7 @@ impl<Block: BlockT, N: Network<Block>> Sink for OutgoingMessages<Block, N>
 
 			// announce our block hash to peers and propagate the
 			// message.
-			self.network.announce(target_hash);
+			self.network.announce(target_hash, Vec::new()); // TODO: Use additional data once available.
 
 			let topic = round_topic::<Block>(self.round, self.set_id);
 			self.network.gossip_message(topic, message.encode(), false);

core/finality-grandpa/src/communication/tests.rs

@@ -88,7 +88,7 @@ impl super::Network<Block> for TestNetwork {
 	}
 
 	/// Inform peers that a block with given hash should be downloaded.
-	fn announce(&self, block: Hash) {
+	fn announce(&self, block: Hash, associated_data: Vec<u8>) {
 		let _ = self.sender.unbounded_send(Event::Announce(block));
 	}
 }

core/finality-grandpa/src/until_imported.rs

@@ -473,6 +473,7 @@ mod tests {
 				header,
 				is_new_best: false,
 				retracted: vec![],
+				associated_data: vec![],
 			}).unwrap();
 		}
 	}

core/network/src/chain.rs

@@ -16,10 +16,10 @@
 
 //! Blockchain access trait
 
-use client::{self, Client as SubstrateClient, ClientInfo, BlockStatus, CallExecutor};
+use client::{self, Client as SubstrateClient, ClientInfo, CallExecutor};
 use client::error::Error;
 use client::light::fetcher::ChangesProof;
-use consensus::{BlockImport, Error as ConsensusError};
+use consensus::{BlockImport, BlockStatus, Error as ConsensusError};
 use sr_primitives::traits::{Block as BlockT, Header as HeaderT};
 use sr_primitives::generic::{BlockId};
 use sr_primitives::Justification;

core/network/src/config.rs

@@ -26,7 +26,7 @@ use crate::chain::{Client, FinalityProofProvider};
 use crate::on_demand_layer::OnDemand;
 use crate::service::{ExHashT, TransactionPool};
 use bitflags::bitflags;
-use consensus::import_queue::ImportQueue;
+use consensus::{block_validation::BlockAnnounceValidator, import_queue::ImportQueue};
 use sr_primitives::traits::{Block as BlockT};
 use std::sync::Arc;
 use libp2p::identity::{Keypair, secp256k1, ed25519};
@@ -80,6 +80,9 @@ pub struct Params<B: BlockT, S, H: ExHashT> {
 
 	/// Customization of the network. Use this to plug additional networking capabilities.
 	pub specialization: S,
+
+	/// Type to check incoming block announcements.
+	pub block_announce_validator: Box<dyn BlockAnnounceValidator<B> + Send>
 }
 
 bitflags! {