Merge branch 'master' into giles-split-consensus

bin/node-template/node/src/service.rs

@@ -25,16 +25,28 @@ type FullClient = sc_service::TFullClient<Block, RuntimeApi, Executor>;
 type FullBackend = sc_service::TFullBackend<Block>;
 type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
 
-pub fn new_partial(config: &Configuration) -> Result<sc_service::PartialComponents<
-	FullClient, FullBackend, FullSelectChain,
-	sc_consensus::DefaultImportQueue<Block, FullClient>,
-	sc_transaction_pool::FullPool<Block, FullClient>,
-	(
-		sc_finality_grandpa::GrandpaBlockImport<FullBackend, Block, FullClient, FullSelectChain>,
-		sc_finality_grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
-		Option<Telemetry>,
-	)
->, ServiceError> {
+pub fn new_partial(
+	config: &Configuration,
+) -> Result<
+	sc_service::PartialComponents<
+		FullClient,
+		FullBackend,
+		FullSelectChain,
+		sc_consensus::DefaultImportQueue<Block, FullClient>,
+		sc_transaction_pool::FullPool<Block, FullClient>,
+		(
+			sc_finality_grandpa::GrandpaBlockImport<
+				FullBackend,
+				Block,
+				FullClient,
+				FullSelectChain,
+			>,
+			sc_finality_grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
+			Option<Telemetry>,
+		),
+	>,
+	ServiceError,
+> {
 	if config.keystore_remote.is_some() {
 		return Err(ServiceError::Other(format!("Remote Keystores are not supported.")))
 	}

bin/node/cli/src/service.rs

@@ -41,15 +41,13 @@ type LightClient = sc_service::TLightClient<Block, RuntimeApi, Executor>;
 
 pub fn new_partial(
 	config: &Configuration,
-) -> Result<sc_service::PartialComponents<
-	FullClient, FullBackend, FullSelectChain,
-	sc_consensus::DefaultImportQueue<Block, FullClient>,
-	sc_transaction_pool::FullPool<Block, FullClient>,
-	(
-		impl Fn(
-			node_rpc::DenyUnsafe,
-			sc_rpc::SubscriptionTaskExecutor,
-		) -> node_rpc::IoHandler,
+) -> Result<
+	sc_service::PartialComponents<
+		FullClient,
+		FullBackend,
+		FullSelectChain,
+		sc_consensus::DefaultImportQueue<Block, FullClient>,
+		sc_transaction_pool::FullPool<Block, FullClient>,
 		(
 			impl Fn(node_rpc::DenyUnsafe, sc_rpc::SubscriptionTaskExecutor) -> node_rpc::IoHandler,
 			(
@@ -589,29 +587,18 @@ pub fn new_light(config: Configuration) -> Result<TaskManager, ServiceError> {
 
 #[cfg(test)]
 mod tests {
-	use std::{sync::Arc, borrow::Cow, convert::TryInto};
-	use sc_consensus_babe::{CompatibleDigestItem, BabeIntermediate, INTERMEDIATE_KEY};
-	use sc_consensus_epochs::descendent_query;
-	use sp_consensus::{BlockOrigin, Environment, Proposer};
-	use sc_consensus::{BlockImportParams, ForkChoiceStrategy, BlockImport,};
-	use node_primitives::{Block, DigestItem, Signature};
-	use node_runtime::{BalancesCall, Call, UncheckedExtrinsic, Address};
-	use node_runtime::constants::{currency::CENTS, time::SLOT_DURATION};
+	use crate::service::{new_full_base, new_light_base, NewFullBase};
 	use codec::Encode;
 	use node_primitives::{Block, DigestItem, Signature};
 	use node_runtime::{
 		constants::{currency::CENTS, time::SLOT_DURATION},
 		Address, BalancesCall, Call, UncheckedExtrinsic,
 	};
 	use sc_client_api::BlockBackend;
+	use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy};
 	use sc_consensus_babe::{BabeIntermediate, CompatibleDigestItem, INTERMEDIATE_KEY};
 	use sc_consensus_epochs::descendent_query;
-	use sc_keystore::LocalKeystore;
-	use sc_service_test::TestNetNode;
-	use sc_transaction_pool_api::{ChainEvent, MaintainedTransactionPool};
-	use sp_consensus::{
-		BlockImport, BlockImportParams, BlockOrigin, Environment, ForkChoiceStrategy, Proposer,
-	};
+	use sp_consensus::{BlockOrigin, Environment, Proposer};
 	use sp_core::{crypto::Pair as CryptoPair, Public, H256};
 	use sp_inherents::InherentDataProvider;
 	use sp_keyring::AccountKeyring;

bin/node/executor/tests/basic.rs

@@ -874,9 +874,8 @@ fn full_wasm_block_import_works_with_changes_trie() {
 #[test]
 fn should_import_block_with_test_client() {
 	use node_testing::client::{
-		ClientBlockImportExt, TestClientBuilderExt, TestClientBuilder,
+		sp_consensus::BlockOrigin, ClientBlockImportExt, TestClientBuilder, TestClientBuilderExt,
 	};
-	use sp_consensus::BlockOrigin;
 
 	let mut client = TestClientBuilder::new().build();
 	let block1 = changes_trie_block();

bin/node/testing/src/bench.rs

@@ -22,22 +22,15 @@
 //! can pregenerate seed database and `clone` it for every iteration of your benchmarks
 //! or tests to get consistent, smooth benchmark experience!
 
-use std::{sync::Arc, path::{Path, PathBuf}, collections::BTreeMap};
-
-use node_primitives::Block;
-use crate::client::{Client, Backend};
-use crate::keyring::*;
-use sc_client_db::PruningMode;
-use sc_executor::{NativeExecutor, WasmExecutionMethod};
-use sc_consensus::{
-	BlockImport, BlockImportParams,
-	ForkChoiceStrategy, ImportResult, ImportedAux
+use std::{
+	collections::BTreeMap,
+	path::{Path, PathBuf},
+	sync::Arc,
 };
-use sp_consensus::BlockOrigin;
-use sp_runtime::{
-	generic::BlockId,
-	OpaqueExtrinsic,
-	traits::{Block as BlockT, Verify, Zero, IdentifyAccount},
+
+use crate::{
+	client::{Backend, Client},
+	keyring::*,
 };
 use codec::{Decode, Encode};
 use futures::executor;
@@ -46,18 +39,16 @@ use node_runtime::{
 	constants::currency::DOLLARS, AccountId, BalancesCall, Call, CheckedExtrinsic, MinimumPeriod,
 	Signature, SystemCall, UncheckedExtrinsic,
 };
-use sc_block_builder::BlockBuilderProvider;
+use sc_block_builder::{BlockBuilderApi, BlockBuilderProvider};
 use sc_client_api::{
 	execution_extensions::{ExecutionExtensions, ExecutionStrategies},
 	BlockBackend, ExecutionStrategy,
 };
 use sc_client_db::PruningMode;
+use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy, ImportResult, ImportedAux};
 use sc_executor::{NativeExecutor, WasmExecutionMethod};
 use sp_api::ProvideRuntimeApi;
-use sp_block_builder::BlockBuilder;
-use sp_consensus::{
-	BlockImport, BlockImportParams, BlockOrigin, ForkChoiceStrategy, ImportResult, ImportedAux,
-};
+use sp_consensus::BlockOrigin;
 use sp_core::{blake2_256, ed25519, sr25519, traits::SpawnNamed, ExecutionContext, Pair, Public};
 use sp_inherents::InherentData;
 use sp_runtime::{

client/basic-authorship/src/basic_authorship.rs

@@ -480,11 +480,7 @@ mod tests {
 
 	use futures::executor::block_on;
 	use parking_lot::Mutex;
-	use sp_consensus::{Proposer,BlockOrigin};
-	use substrate_test_runtime_client::{
-		prelude::*, TestClientBuilder, runtime::{Extrinsic, Transfer}, TestClientBuilderExt,
-	};
-	use sc_transaction_pool_api::{ChainEvent, MaintainedTransactionPool, TransactionSource};
+	use sc_consensus::{BlockOrigin, Proposer};
 	use sc_transaction_pool::BasicPool;
 	use sc_transaction_pool_api::{ChainEvent, MaintainedTransactionPool, TransactionSource};
 	use sp_api::Core;

client/consensus/aura/src/import_queue.rs

@@ -22,30 +22,20 @@ use crate::{aura_err, authorities, find_pre_digest, slot_author, AuthorityId, Er
 use codec::{Codec, Decode, Encode};
 use log::{debug, info, trace};
 use prometheus_endpoint::Registry;
-use codec::{Encode, Decode, Codec};
-use sp_consensus::{
-	BlockOrigin,
-	CanAuthorWith,
-	Error as ConsensusError,
-};
+use sc_client_api::{backend::AuxStore, BlockOf, UsageProvider};
 use sc_consensus::{
-	block_import::{BlockImport, ForkChoiceStrategy, BlockImportParams},
-	import_queue::{
-		Verifier, BasicQueue, DefaultImportQueue, BoxJustificationImport,
-	}
+	block_import::{BlockImport, BlockImportParams, ForkChoiceStrategy},
+	import_queue::{BasicQueue, BoxJustificationImport, DefaultImportQueue, Verifier},
 };
-use sc_client_api::{BlockOf, UsageProvider, backend::AuxStore};
-use sp_blockchain::{well_known_cache_keys::{self, Id as CacheKeyId}, ProvideCache, HeaderBackend};
+use sc_consensus_slots::{check_equivocation, CheckedHeader, InherentDataProviderExt};
+use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG, CONSENSUS_TRACE};
+use sp_api::{ApiExt, ProvideRuntimeApi};
 use sp_block_builder::BlockBuilder as BlockBuilderApi;
 use sp_blockchain::{
 	well_known_cache_keys::{self, Id as CacheKeyId},
 	HeaderBackend, ProvideCache,
 };
-use sp_consensus::{
-	import_queue::{BasicQueue, BoxJustificationImport, DefaultImportQueue, Verifier},
-	BlockImport, BlockImportParams, BlockOrigin, CanAuthorWith, Error as ConsensusError,
-	ForkChoiceStrategy,
-};
+use sp_consensus::{BlockOrigin, CanAuthorWith, Error as ConsensusError};
 use sp_consensus_aura::{
 	digests::CompatibleDigestItem, inherents::AuraInherentData, AuraApi, ConsensusLog,
 	AURA_ENGINE_ID,

client/consensus/aura/src/lib.rs

@@ -44,14 +44,8 @@ use log::{debug, trace};
 
 use codec::{Codec, Decode, Encode};
 
-use sp_consensus::{
-	BlockOrigin, Environment, Proposer, CanAuthorWith,
-	Error as ConsensusError, SelectChain,
-};
-use sc_consensus::{
-	BlockImport,StateAction,ForkChoiceStrategy, BlockImportParams
-};
 use sc_client_api::{backend::AuxStore, BlockOf, UsageProvider};
+use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy, StateAction};
 use sc_consensus_slots::{
 	BackoffAuthoringBlocksStrategy, InherentDataProviderExt, SlotInfo, StorageChanges,
 };
@@ -60,8 +54,7 @@ use sp_api::ProvideRuntimeApi;
 use sp_application_crypto::{AppKey, AppPublic};
 use sp_blockchain::{HeaderBackend, ProvideCache, Result as CResult};
 use sp_consensus::{
-	BlockImport, BlockImportParams, BlockOrigin, CanAuthorWith, Environment,
-	Error as ConsensusError, ForkChoiceStrategy, Proposer, SelectChain, StateAction,
+	BlockOrigin, CanAuthorWith, Environment, Error as ConsensusError, Proposer, SelectChain,
 };
 use sp_consensus_slots::Slot;
 use sp_core::crypto::{Pair, Public};
@@ -392,17 +385,22 @@ where
 		vec![<DigestItemFor<B> as CompatibleDigestItem<P::Signature>>::aura_pre_digest(slot)]
 	}
 
-	fn block_import_params(&self) -> Box<dyn Fn(
-		B::Header,
-		&B::Hash,
-		Vec<B::Extrinsic>,
-		StorageChanges<sp_api::TransactionFor<C, B>, B>,
-		Self::Claim,
-		Self::EpochData,
-	) -> Result<
-		sc_consensus::BlockImportParams<B, sp_api::TransactionFor<C, B>>,
-		sp_consensus::Error> + Send + 'static>
-	{
+	fn block_import_params(
+		&self,
+	) -> Box<
+		dyn Fn(
+				B::Header,
+				&B::Hash,
+				Vec<B::Extrinsic>,
+				StorageChanges<sp_api::TransactionFor<C, B>, B>,
+				Self::Claim,
+				Self::EpochData,
+			) -> Result<
+				sc_consensus::BlockImportParams<B, sp_api::TransactionFor<C, B>>,
+				sp_consensus::Error,
+			> + Send
+			+ 'static,
+	> {
 		let keystore = self.keystore.clone();
 		Box::new(move |header, header_hash, body, storage_changes, public, _epoch| {
 			// sign the pre-sealed hash of the block and then
@@ -433,9 +431,8 @@ where
 			let mut import_block = BlockImportParams::new(BlockOrigin::Own, header);
 			import_block.post_digests.push(signature_digest_item);
 			import_block.body = Some(body);
-			import_block.state_action = StateAction::ApplyChanges(
-				sc_consensus::StorageChanges::Changes(storage_changes)
-			);
+			import_block.state_action =
+				StateAction::ApplyChanges(sc_consensus::StorageChanges::Changes(storage_changes));
 			import_block.fork_choice = Some(ForkChoiceStrategy::LongestChain);
 
 			Ok(import_block)
@@ -561,17 +558,10 @@ where
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use sp_consensus::{
-		NoNetwork as DummyOracle, Proposal, AlwaysCanAuthor, DisableProofRecording,
-		SlotData,
-	};
-	use sc_consensus::BoxJustificationImport;
-	use sc_network_test::{Block as TestBlock, *};
-	use sp_runtime::traits::{Block as BlockT, DigestFor};
-	use sc_network::config::ProtocolConfig;
 	use parking_lot::Mutex;
 	use sc_block_builder::BlockBuilderProvider;
 	use sc_client_api::BlockchainEvents;
+	use sc_consensus::BoxJustificationImport;
 	use sc_consensus_slots::{BackoffAuthoringOnFinalizedHeadLagging, SimpleSlotWorker};
 	use sc_keystore::LocalKeystore;
 	use sc_network::config::ProtocolConfig;