core: make block justification optional

core/client/src/client.rs

@@ -593,7 +593,7 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 		origin: BlockOrigin,
 		hash: Block::Hash,
 		import_headers: PrePostHeader<Block::Header>,
-		justification: Justification,
+		justification: Option<Justification>,
 		body: Option<Vec<Block::Extrinsic>>,
 		authorities: Option<Vec<AuthorityId>>,
 		finalized: bool,
@@ -678,7 +678,7 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 		transaction.set_block_data(
 			import_headers.post().clone(),
 			body,
-			Some(justification),
+			justification,
 			leaf_state,
 		)?;
 
@@ -858,7 +858,7 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 		-> error::Result<Option<SignedBlock<Block>>>
 	{
 		Ok(match (self.header(id)?, self.body(id)?, self.justification(id)?) {
-			(Some(header), Some(extrinsics), Some(justification)) =>
+			(Some(header), Some(extrinsics), justification) =>
 				Some(SignedBlock { block: Block::new(header, extrinsics), justification }),
 			_ => None,
 		})

core/consensus/aura/src/lib.rs

@@ -60,7 +60,7 @@ use codec::Encode;
 use consensus_common::{Authorities, BlockImport, Environment, Proposer};
 use client::ChainHead;
 use consensus_common::{ImportBlock, BlockOrigin};
-use runtime_primitives::{generic, generic::BlockId};
+use runtime_primitives::{generic, generic::BlockId, Justification};
 use runtime_primitives::traits::{Block, Header, Digest, DigestItemFor};
 use network::import_queue::{Verifier, BasicQueue};
 use primitives::{AuthorityId, ed25519};
@@ -243,7 +243,7 @@ pub fn start_aura<B, C, E, I, SO, Error>(
 						let import_block = ImportBlock {
 							origin: BlockOrigin::Own,
 							header,
-							justification: Vec::new(),
+							justification: None,
 							post_digests: vec![item],
 							body: Some(body),
 							finalized: false,
@@ -366,7 +366,7 @@ impl<B: Block, C, E> Verifier<B> for AuraVerifier<C, E> where
 		&self,
 		origin: BlockOrigin,
 		header: B::Header,
-		_justification: Vec<u8>,
+		_justification: Option<Justification>,
 		body: Option<Vec<B::Extrinsic>>
 	) -> Result<(ImportBlock<B>, Option<Vec<AuthorityId>>), String> {
 		let slot_now = slot_now(self.config.slot_duration)
@@ -392,7 +392,7 @@ impl<B: Block, C, E> Verifier<B> for AuraVerifier<C, E> where
 				let import_block = ImportBlock {
 					origin,
 					header: pre_header,
-					justification: Vec::new(),
+					justification: None,
 					post_digests: vec![item],
 					body,
 					finalized: false,

core/consensus/common/src/block_import.rs

@@ -69,8 +69,8 @@ pub struct ImportBlock<Block: BlockT> {
 	/// re-executed in a runtime that checks digest equivalence -- the
 	/// post-runtime digests are pushed back on after.
 	pub header: Block::Header,
-	/// Justification provided for this block from the outside:.
-	pub justification: Justification,
+	/// Justification provided for this block from the outside.
+	pub justification: Option<Justification>,
 	/// Digest items that have been added after the runtime for external
 	/// work, like a consensus signature.
 	pub post_digests: Vec<DigestItemFor<Block>>,
@@ -91,7 +91,7 @@ impl<Block: BlockT> ImportBlock<Block> {
 		-> (
 			BlockOrigin,
 			<Block as BlockT>::Header,
-			Justification,
+			Option<Justification>,
 			Vec<DigestItemFor<Block>>,
 			Option<Vec<<Block as BlockT>::Extrinsic>>,
 			bool,

core/network/src/import_queue.rs

@@ -31,6 +31,7 @@ use parking_lot::{Condvar, Mutex, RwLock};
 use network_libp2p::{NodeIndex, Severity};
 use primitives::AuthorityId;
 
+use runtime_primitives::Justification;
 use runtime_primitives::traits::{Block as BlockT, Header as HeaderT, NumberFor, Zero};
 
 pub use blocks::BlockData;
@@ -57,7 +58,7 @@ pub trait Verifier<B: BlockT>: Send + Sync + Sized {
 		&self,
 		origin: BlockOrigin,
 		header: B::Header,
-		justification: Vec<u8>,
+		justification: Option<Justification>,
 		body: Option<Vec<B::Extrinsic>>
 	) -> Result<(ImportBlock<B>, Option<Vec<AuthorityId>>), String>;
 }
@@ -411,7 +412,7 @@ fn import_single_block<B: BlockT, V: Verifier<B>>(
 	let block = block.block;
 
 	let (header, justification) = match (block.header, block.justification) {
-		(Some(header), Some(justification)) => (header, justification),
+		(Some(header), justification) => (header, justification),
 		(None, _) => {
 			if let Some(peer) = peer {
 				debug!(target: "sync", "Header {} was not provided by {} ", block.hash, peer);
@@ -420,14 +421,6 @@ fn import_single_block<B: BlockT, V: Verifier<B>>(
 			}
 			return Err(BlockImportError::IncompleteHeader(peer)) //TODO: use persistent ID
 		},
-		(_, None) => {
-			if let Some(peer) = peer {
-				debug!(target: "sync", "Justification set for block {} was not provided by {} ", block.hash, peer);
-			} else {
-				debug!(target: "sync", "Justification set for block {} was not provided", block.hash);
-			}
-			return Err(BlockImportError::IncompleteJustification(peer)) //TODO: use persistent ID
-		}
 	};
 
 	let number = header.number().clone();
@@ -555,15 +548,15 @@ impl<B: BlockT> Verifier<B> for PassThroughVerifier {
 		&self,
 		origin: BlockOrigin,
 		header: B::Header,
-		justification: Vec<u8>,
+		justification: Option<Justification>,
 		body: Option<Vec<B::Extrinsic>>
 	) -> Result<(ImportBlock<B>, Option<Vec<AuthorityId>>), String> {
 		Ok((ImportBlock {
 			origin,
 			header,
 			body,
 			finalized: self.0,
-			justification: justification,
+			justification,
 			post_digests: vec![],
 			auxiliary: Vec::new(),
 		}, None))
@@ -745,15 +738,16 @@ pub mod tests {
 		);
 	}
 
-	#[test]
-	fn import_single_good_block_without_justification_fails() {
-		let (_, _, _, mut block) = prepare_good_block();
-		block.block.justification = None;
-		assert_eq!(
-			import_single_block(&test_client::new(), BlockOrigin::File, block, Arc::new(PassThroughVerifier(true))),
-			Err(BlockImportError::IncompleteJustification(Some(0)))
-		);
-	}
+	// FIXME: replace with test where `IncompleteJustification` error is created by the `BlockImport` handle
+	// #[test]
+	// fn import_single_good_block_without_justification_fails() {
+	// 	let (_, _, _, mut block) = prepare_good_block();
+	// 	block.block.justification = None;
+	// 	assert_eq!(
+	// 		import_single_block(&test_client::new(), BlockOrigin::File, block, Arc::new(PassThroughVerifier(true))),
+	// 		Err(BlockImportError::IncompleteJustification(Some(0)))
+	// 	);
+	// }
 
 	#[test]
 	fn process_import_result_works() {

core/rpc/src/chain/tests.rs

@@ -72,11 +72,10 @@ fn should_return_a_block() {
 	let block_hash = block.hash();
 	api.client.justify_and_import(BlockOrigin::Own, block).unwrap();
 
-
-	// Genesis block is not justified, so we can't query it?
+	// Genesis block is not justified
 	assert_matches!(
 		api.block(Some(api.client.genesis_hash()).into()),
-		Ok(None)
+		Ok(Some(SignedBlock { justification: None, .. }))
 	);
 
 	assert_matches!(

core/service/src/chain_ops.rs

@@ -116,7 +116,7 @@ pub fn import_blocks<F, E, R>(mut config: FactoryFullConfiguration<F>, exit: E,
 			let hash = header.hash();
 			let block  = message::BlockData::<F::Block> {
 				hash: hash,
-				justification: Some(signed.justification),
+				justification: signed.justification,
 				header: Some(header),
 				body: Some(extrinsics),
 				receipt: None,

core/sr-primitives/src/generic/block.rs

@@ -116,7 +116,7 @@ pub struct SignedBlock<Block> {
 	/// Full block.
 	pub block: Block,
 	/// Block justification.
-	pub justification: Justification,
+	pub justification: Option<Justification>,
 }
 
 // TODO: Remove Deserialize for SignedBlock once RPC no longer needs it #1098

core/test-client/src/client_ext.rs

@@ -47,7 +47,7 @@ impl<B, E, RA> TestClient for Client<B, E, runtime::Block, RA>
 		let import = ImportBlock {
 			origin,
 			header: block.header,
-			justification: vec![],
+			justification: Some(vec![]),
 			post_digests: vec![],
 			body: Some(block.extrinsics),
 			finalized: false,