Merge remote-tracking branch 'origin/master' into mku-genesis-build-for-runtime-genesis-config

Author: parity-processbot

Cargo.lock

@@ -106,8 +106,10 @@ members = [
 	"frame/election-provider-support/benchmarking",
 	"frame/election-provider-support/solution-type",
 	"frame/election-provider-support/solution-type/fuzzer",
+	"frame/examples",
 	"frame/examples/basic",
 	"frame/examples/offchain-worker",
+	"frame/examples/kitchensink",
 	"frame/examples/dev-mode",
 	"frame/examples/default-config",
 	"frame/executive",
@@ -199,6 +201,7 @@ members = [
 	"primitives/core",
 	"primitives/core/hashing",
 	"primitives/core/hashing/proc-macro",
+	"primitives/crypto/ec-utils",
 	"primitives/database",
 	"primitives/debug-derive",
 	"primitives/externalities",

Cargo.toml

@@ -25,14 +25,12 @@ use crate::{
 use sc_cli::{CliConfiguration, ImportParams, Result, SharedParams};
 use sc_service::{Configuration, NativeExecutionDispatch};
 use sp_runtime::traits::Block;
-use std::str::FromStr;
 
 impl InspectCmd {
 	/// Run the inspect command, passing the inspector.
 	pub fn run<B, RA, D>(&self, config: Configuration) -> Result<()>
 	where
 		B: Block,
-		B::Hash: FromStr,
 		RA: Send + Sync + 'static,
 		D: NativeExecutionDispatch + 'static,
 	{

bin/node/inspect/src/command.rs

@@ -487,10 +487,7 @@ pub struct BlockImportOperation<Block: BlockT> {
 	set_head: Option<Block::Hash>,
 }
 
-impl<Block: BlockT> BlockImportOperation<Block>
-where
-	Block::Hash: Ord,
-{
+impl<Block: BlockT> BlockImportOperation<Block> {
 	fn apply_storage(
 		&mut self,
 		storage: Storage,
@@ -519,10 +516,7 @@ where
 	}
 }
 
-impl<Block: BlockT> backend::BlockImportOperation<Block> for BlockImportOperation<Block>
-where
-	Block::Hash: Ord,
-{
+impl<Block: BlockT> backend::BlockImportOperation<Block> for BlockImportOperation<Block> {
 	type State = InMemoryBackend<HashFor<Block>>;
 
 	fn state(&self) -> sp_blockchain::Result<Option<&Self::State>> {
@@ -611,20 +605,14 @@ where
 ///
 /// > **Warning**: Doesn't support all the features necessary for a proper database. Only use this
 /// > struct for testing purposes. Do **NOT** use in production.
-pub struct Backend<Block: BlockT>
-where
-	Block::Hash: Ord,
-{
+pub struct Backend<Block: BlockT> {
 	states: RwLock<HashMap<Block::Hash, InMemoryBackend<HashFor<Block>>>>,
 	blockchain: Blockchain<Block>,
 	import_lock: RwLock<()>,
 	pinned_blocks: RwLock<HashMap<Block::Hash, i64>>,
 }
 
-impl<Block: BlockT> Backend<Block>
-where
-	Block::Hash: Ord,
-{
+impl<Block: BlockT> Backend<Block> {
 	/// Create a new instance of in-mem backend.
 	///
 	/// # Warning
@@ -650,10 +638,7 @@ where
 	}
 }
 
-impl<Block: BlockT> backend::AuxStore for Backend<Block>
-where
-	Block::Hash: Ord,
-{
+impl<Block: BlockT> backend::AuxStore for Backend<Block> {
 	fn insert_aux<
 		'a,
 		'b: 'a,
@@ -673,10 +658,7 @@ where
 	}
 }
 
-impl<Block: BlockT> backend::Backend<Block> for Backend<Block>
-where
-	Block::Hash: Ord,
-{
+impl<Block: BlockT> backend::Backend<Block> for Backend<Block> {
 	type BlockImportOperation = BlockImportOperation<Block>;
 	type Blockchain = Blockchain<Block>;
 	type State = InMemoryBackend<HashFor<Block>>;
@@ -809,7 +791,7 @@ where
 	}
 }
 
-impl<Block: BlockT> backend::LocalBackend<Block> for Backend<Block> where Block::Hash: Ord {}
+impl<Block: BlockT> backend::LocalBackend<Block> for Backend<Block> {}
 
 /// Check that genesis storage is valid.
 pub fn check_genesis_storage(storage: &Storage) -> sp_blockchain::Result<()> {

client/api/src/in_mem.rs

@@ -54,7 +54,6 @@ impl CheckBlockCmd {
 		B: BlockT + for<'de> serde::Deserialize<'de>,
 		C: BlockBackend<B> + HeaderBackend<B> + Send + Sync + 'static,
 		IQ: sc_service::ImportQueue<B> + 'static,
-		B::Hash: FromStr,
 		<B::Hash as FromStr>::Err: Debug,
 		<<B::Header as HeaderT>::Number as FromStr>::Err: Debug,
 	{

client/cli/src/commands/check_block_cmd.rs

@@ -59,7 +59,6 @@ impl ExportStateCmd {
 		B: BlockT,
 		C: UsageProvider<B> + StorageProvider<B, BA> + HeaderBackend<B>,
 		BA: sc_client_api::backend::Backend<B>,
-		B::Hash: FromStr,
 		<B::Hash as FromStr>::Err: Debug,
 		<<B::Header as HeaderT>::Number as FromStr>::Err: Debug,
 	{

client/cli/src/commands/export_state_cmd.rs

@@ -113,7 +113,6 @@ impl BlockNumberOrHash {
 	/// Parse the inner value as `BlockId`.
 	pub fn parse<B: BlockT>(&self) -> Result<BlockId<B>, String>
 	where
-		B::Hash: FromStr,
 		<B::Hash as FromStr>::Err: std::fmt::Debug,
 		NumberFor<B>: FromStr,
 		<NumberFor<B> as FromStr>::Err: std::fmt::Debug,

client/cli/src/params/mod.rs

@@ -718,7 +718,6 @@ pub fn run_grandpa_voter<Block: BlockT, BE: 'static, C, N, S, SC, VR>(
 	grandpa_params: GrandpaParams<Block, C, N, S, SC, VR>,
 ) -> sp_blockchain::Result<impl Future<Output = ()> + Send>
 where
-	Block::Hash: Ord,
 	BE: Backend<Block> + 'static,
 	N: NetworkT<Block> + Sync + 'static,
 	S: SyncingT<Block> + Sync + 'static,

client/consensus/grandpa/src/lib.rs

@@ -423,10 +423,7 @@ impl<B: BlockT> StateBackend<HashFor<B>> for BenchmarkingState<B> {
 		&self,
 		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
 		state_version: StateVersion,
-	) -> (B::Hash, Self::Transaction)
-	where
-		B::Hash: Ord,
-	{
+	) -> (B::Hash, Self::Transaction) {
 		self.state
 			.borrow()
 			.as_ref()
@@ -438,10 +435,7 @@ impl<B: BlockT> StateBackend<HashFor<B>> for BenchmarkingState<B> {
 		child_info: &ChildInfo,
 		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
 		state_version: StateVersion,
-	) -> (B::Hash, bool, Self::Transaction)
-	where
-		B::Hash: Ord,
-	{
+	) -> (B::Hash, bool, Self::Transaction) {
 		self.state
 			.borrow()
 			.as_ref()

client/db/src/bench.rs

@@ -243,10 +243,7 @@ impl<B: BlockT> StateBackend<HashFor<B>> for RefTrackingState<B> {
 		&self,
 		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
 		state_version: StateVersion,
-	) -> (B::Hash, Self::Transaction)
-	where
-		B::Hash: Ord,
-	{
+	) -> (B::Hash, Self::Transaction) {
 		self.state.storage_root(delta, state_version)
 	}
 
@@ -255,10 +252,7 @@ impl<B: BlockT> StateBackend<HashFor<B>> for RefTrackingState<B> {
 		child_info: &ChildInfo,
 		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
 		state_version: StateVersion,
-	) -> (B::Hash, bool, Self::Transaction)
-	where
-		B::Hash: Ord,
-	{
+	) -> (B::Hash, bool, Self::Transaction) {
 		self.state.child_storage_root(child_info, delta, state_version)
 	}
 

client/db/src/lib.rs

@@ -171,10 +171,7 @@ impl<S: StateBackend<HashFor<B>>, B: BlockT> StateBackend<HashFor<B>> for Record
 		&self,
 		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
 		state_version: StateVersion,
-	) -> (B::Hash, Self::Transaction)
-	where
-		B::Hash: Ord,
-	{
+	) -> (B::Hash, Self::Transaction) {
 		self.state.storage_root(delta, state_version)
 	}
 
@@ -183,10 +180,7 @@ impl<S: StateBackend<HashFor<B>>, B: BlockT> StateBackend<HashFor<B>> for Record
 		child_info: &ChildInfo,
 		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
 		state_version: StateVersion,
-	) -> (B::Hash, bool, Self::Transaction)
-	where
-		B::Hash: Ord,
-	{
+	) -> (B::Hash, bool, Self::Transaction) {
 		self.state.child_storage_root(child_info, delta, state_version)
 	}
 

client/db/src/record_stats_state.rs

@@ -52,7 +52,7 @@ use sp_api::{
 };
 use sp_blockchain::{
 	self as blockchain, Backend as ChainBackend, CachedHeaderMetadata, Error,
-	HeaderBackend as ChainHeaderBackend, HeaderMetadata,
+	HeaderBackend as ChainHeaderBackend, HeaderMetadata, Info as BlockchainInfo,
 };
 use sp_consensus::{BlockOrigin, BlockStatus, Error as ConsensusError};
 
@@ -717,7 +717,7 @@ where
 				operation,
 				parent_hash,
 				None,
-				info.best_hash,
+				&info,
 				make_notifications,
 			)?;
 		}
@@ -907,52 +907,56 @@ where
 	fn apply_finality_with_block_hash(
 		&self,
 		operation: &mut ClientImportOperation<Block, B>,
-		block: Block::Hash,
+		hash: Block::Hash,
 		justification: Option<Justification>,
-		best_block: Block::Hash,
+		info: &BlockchainInfo<Block>,
 		notify: bool,
 	) -> sp_blockchain::Result<()> {
-		// find tree route from last finalized to given block.
-		let last_finalized = self.backend.blockchain().last_finalized()?;
-
-		if block == last_finalized {
+		if hash == info.finalized_hash {
 			warn!(
 				"Possible safety violation: attempted to re-finalize last finalized block {:?} ",
-				last_finalized
+				hash,
 			);
 			return Ok(())
 		}
 
+		// Find tree route from last finalized to given block.
 		let route_from_finalized =
-			sp_blockchain::tree_route(self.backend.blockchain(), last_finalized, block)?;
+			sp_blockchain::tree_route(self.backend.blockchain(), info.finalized_hash, hash)?;
 
 		if let Some(retracted) = route_from_finalized.retracted().get(0) {
 			warn!(
 				"Safety violation: attempted to revert finalized block {:?} which is not in the \
 				same chain as last finalized {:?}",
-				retracted, last_finalized
+				retracted, info.finalized_hash
 			);
 
 			return Err(sp_blockchain::Error::NotInFinalizedChain)
 		}
 
-		// If there is only one leaf, best block is guaranteed to be
-		// a descendant of the new finalized block. If not,
-		// we need to check.
-		if self.backend.blockchain().leaves()?.len() > 1 {
+		// We may need to coercively update the best block if there is more than one
+		// leaf or if the finalized block number is greater than last best number recorded
+		// by the backend. This last condition may apply in case of consensus implementations
+		// not always checking this condition.
+		let block_number = self
+			.backend
+			.blockchain()
+			.number(hash)?
+			.ok_or(Error::MissingHeader(format!("{hash:?}")))?;
+		if self.backend.blockchain().leaves()?.len() > 1 || info.best_number < block_number {
 			let route_from_best =
-				sp_blockchain::tree_route(self.backend.blockchain(), best_block, block)?;
+				sp_blockchain::tree_route(self.backend.blockchain(), info.best_hash, hash)?;
 
-			// if the block is not a direct ancestor of the current best chain,
+			// If the block is not a direct ancestor of the current best chain,
 			// then some other block is the common ancestor.
-			if route_from_best.common_block().hash != block {
+			if route_from_best.common_block().hash != hash {
 				// NOTE: we're setting the finalized block as best block, this might
 				// be slightly inaccurate since we might have a "better" block
 				// further along this chain, but since best chain selection logic is
 				// plugable we cannot make a better choice here. usages that need
 				// an accurate "best" block need to go through `SelectChain`
 				// instead.
-				operation.op.mark_head(block)?;
+				operation.op.mark_head(hash)?;
 			}
 		}
 
@@ -962,8 +966,8 @@ where
 			operation.op.mark_finalized(finalize_new.hash, None)?;
 		}
 
-		assert_eq!(enacted.last().map(|e| e.hash), Some(block));
-		operation.op.mark_finalized(block, justification)?;
+		assert_eq!(enacted.last().map(|e| e.hash), Some(hash));
+		operation.op.mark_finalized(hash, justification)?;
 
 		if notify {
 			let finalized =
@@ -985,7 +989,7 @@ where
 			let header = self
 				.backend
 				.blockchain()
-				.header(block)?
+				.header(hash)?
 				.expect("Block to finalize expected to be onchain; qed");
 
 			operation.notify_finalized = Some(FinalizeSummary { header, finalized, stale_heads });
@@ -1129,7 +1133,7 @@ where
 	}
 
 	/// Get blockchain info.
-	pub fn chain_info(&self) -> blockchain::Info<Block> {
+	pub fn chain_info(&self) -> BlockchainInfo<Block> {
 		self.backend.blockchain().info()
 	}
 
@@ -1896,8 +1900,8 @@ where
 		justification: Option<Justification>,
 		notify: bool,
 	) -> sp_blockchain::Result<()> {
-		let last_best = self.backend.blockchain().info().best_hash;
-		self.apply_finality_with_block_hash(operation, hash, justification, last_best, notify)
+		let info = self.backend.blockchain().info();
+		self.apply_finality_with_block_hash(operation, hash, justification, &info, notify)
 	}
 
 	fn finalize_block(

client/service/src/client/client.rs

@@ -2001,3 +2001,41 @@ fn use_dalek_ext_works() {
 		.verify_ed25519(a1.hash(), zero_ed_sig(), zero_ed_pub(), vec![])
 		.unwrap());
 }
+
+#[test]
+fn finalize_after_best_block_updates_best() {
+	let mut client = substrate_test_runtime_client::new();
+
+	// G -> A1
+	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	// A1 -> A2
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	// A2 -> A3
+	let a3 = client
+		.new_block_at(a2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	let (header, extrinsics) = a3.clone().deconstruct();
+	let mut import_params = BlockImportParams::new(BlockOrigin::Own, header);
+	import_params.body = Some(extrinsics);
+	import_params.fork_choice = Some(ForkChoiceStrategy::Custom(false));
+	block_on(client.import_block(import_params)).unwrap();
+
+	assert_eq!(client.chain_info().best_hash, a2.hash());
+
+	client.finalize_block(a3.hash(), None).unwrap();
+
+	assert_eq!(client.chain_info().finalized_hash, a3.hash());
+	assert_eq!(client.chain_info().best_hash, a3.hash());
+}