Merge branch 'master' into light_grandpa_importer2

core/client/db/src/lib.rs

@@ -473,7 +473,7 @@ impl<Block: BlockT> state_machine::ChangesTrieRootsStorage<Blake2Hasher> for DbC
 	fn root(&self, anchor: &state_machine::ChangesTrieAnchorBlockId<H256>, block: u64) -> Result<Option<H256>, String> {
 		// check API requirement: we can't get NEXT block(s) based on anchor
 		if block > anchor.number {
-			return Err(format!("Can't get CT root at {} using anchor at {}", block, anchor.number));
+			return Err(format!("Can't get changes trie root at {} using anchor at {}", block, anchor.number));
 		}
 
 		// we need to get hash of the block to resolve changes trie root
@@ -780,6 +780,7 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 
 		let mut meta_updates = Vec::new();
 		let mut last_finalized_hash = self.blockchain.meta.read().finalized_hash;
+
 		if !operation.finalized_blocks.is_empty() {
 			for (block, justification) in operation.finalized_blocks {
 				let block_hash = self.blockchain.expect_block_hash_from_id(&block)?;
@@ -856,7 +857,12 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 			if finalized {
 				// TODO: ensure best chain contains this block.
 				self.ensure_sequential_finalization(header, Some(last_finalized_hash))?;
-				self.note_finalized(&mut transaction, header, hash)?;
+				self.note_finalized(
+					&mut transaction,
+					header,
+					hash,
+					&mut finalization_displaced_leaves,
+				)?;
 			} else {
 				// canonicalize blocks which are old enough, regardless of finality.
 				self.force_delayed_canonicalize(&mut transaction, hash, *header.number())?

core/consensus/aura/src/lib.rs

@@ -735,14 +735,12 @@ mod tests {
 	const TEST_ROUTING_INTERVAL: Duration = Duration::from_millis(50);
 
 	pub struct AuraTestNet {
-		peers: Vec<Arc<Peer<AuraVerifier<
-			PeersFullClient,
-			NothingExtra,
-		>, ()>>>,
+		peers: Vec<Arc<Peer<(), DummySpecialization>>>,
 		started: bool,
 	}
 
 	impl TestNetFactory for AuraTestNet {
+		type Specialization = DummySpecialization;
 		type Verifier = AuraVerifier<PeersFullClient, NothingExtra>;
 		type PeerData = ();
 

core/consensus/common/src/block_import.rs

@@ -33,12 +33,38 @@ pub enum ImportResult {
 	KnownBad,
 	/// Block parent is not in the chain.
 	UnknownParent,
-	/// Added to the import queue but must be justified
-	/// (usually required to safely enact consensus changes).
-	NeedsJustification,
-	/// Added to the import queue but finality proof is required
-	/// (usually required to safely enact consensus changes).
-	NeedsFinalityProof,
+}
+
+/// Auxiliary data associated with an imported block result.
+#[derive(Debug, PartialEq, Eq)]
+pub struct ImportedAux {
+	/// Clear all pending justification requests.
+	pub clear_justification_requests: bool,
+	/// Request a justification for the given block.
+	pub needs_justification: bool,
+	/// Clear all pending finality proof requests. TODO: do we need this??????????????????????!!!!!!!!!!!!!!!!!!!!!!!!!
+	pub clear_finality_proof_requests: bool,
+	/// Request a finality proof for the given block.
+	pub needs_finality_proof: bool,
+}
+
+impl Default for ImportedAux {
+	fn default() -> ImportedAux {
+		ImportedAux {
+			clear_justification_requests: false,
+			needs_justification: false,
+			clear_finality_proof_requests: false,
+			needs_finality_proof: false,
+		}
+	}
+}
+
+impl ImportResult {
+	/// Returns default value for `ImportResult::Imported` with both
+	/// `clear_justification_requests` and `needs_justification` set to false.
+	pub fn imported() -> ImportResult {
+		ImportResult::Imported(ImportedAux::default())
+	}
 }
 
 /// Block data origin.