Remove all (non-dev) client references from frame, activate dependency enforcer (#4184)

* Move transaction pool to primitives

* move backend, errors into primitives

* remove unused client depencies

* Move rpc-api into primitives

* Move peerset back to client

* Move rpc/api back to client, move palette/support/rpc into utils

* move support-rpc into subfolder

* move system-rpc into utils

* move transaction-pool  and -graph back into client

* fix broken imports

* Clean up test primitives

* Make support test utils independent of frame

* remove unnecessary node dependencies from service

* Reactivate dependency script:
 - only enforce the now achieved status quo will remain
 - allow for primitives to depend on /client for now without failing
 - more discriptive error message so people understand, what it wants
 - minor fix to differentiative between ../client and /client (which may be a subfolder)
 - don't allow this to fail anylonger.

* fix doc comment

* 'Should not' rather than 'must not'.

* Revert unwanted dependency changes

* fix faulty import

* fixup derive_more version

* fix wrong import path

substrate/client/consensus/aura/Cargo.toml

@@ -22,6 +22,7 @@ keystore = { package = "substrate-keystore", path = "../../keystore" }
 log = "0.4.8"
 parking_lot = "0.9.0"
 primitives = { package = "substrate-primitives", path = "../../../primitives/core" }
+sp-blockchain = { path = "../../../primitives/blockchain" }
 runtime_io = { package = "sr-io", path = "../../../primitives/sr-io" }
 runtime_version = { package = "sr-version", path = "../../../primitives/sr-version" }
 slots = { package = "substrate-consensus-slots", path = "../slots" }

substrate/client/consensus/aura/src/lib.rs

@@ -38,10 +38,12 @@ use consensus_common::{self, BlockImport, Environment, Proposer,
 use consensus_common::import_queue::{
 	Verifier, BasicQueue, BoxBlockImport, BoxJustificationImport, BoxFinalityProofImport,
 };
-use client_api::{ error::Result as CResult, backend::AuxStore };
+use client_api::backend::AuxStore;
 use client::{
-	blockchain::ProvideCache, BlockOf,
-	well_known_cache_keys::{self, Id as CacheKeyId},
+	blockchain::ProvideCache, BlockOf
+};
+use sp_blockchain::{
+	Result as CResult, well_known_cache_keys::{self, Id as CacheKeyId},
 };
 
 use block_builder_api::BlockBuilder as BlockBuilderApi;
@@ -55,6 +57,7 @@ use inherents::{InherentDataProviders, InherentData};
 use futures::prelude::*;
 use parking_lot::Mutex;
 use log::{debug, info, trace};
+use sp_blockchain;
 
 use sp_timestamp::{
 	TimestampInherentData, InherentType as TimestampInherent, InherentError as TIError
@@ -95,7 +98,7 @@ impl SlotDuration {
 		A: Codec,
 		B: BlockT,
 		C: AuxStore + ProvideRuntimeApi,
-		C::Api: AuraApi<B, A, Error = client::error::Error>,
+		C::Api: AuraApi<B, A, Error = sp_blockchain::Error>,
 	{
 		slots::SlotDuration::get_or_compute(client, |a, b| a.slot_duration(b)).map(Self)
 	}
@@ -340,7 +343,7 @@ enum Error<B: BlockT> {
 	BadSignature(B::Hash),
 	#[display(fmt = "Rejecting block too far in future")]
 	TooFarInFuture,
-	Client(client::error::Error),
+	Client(sp_blockchain::Error),
 	DataProvider(String),
 	Runtime(String),
 }
@@ -448,7 +451,7 @@ impl<C, P, T> AuraVerifier<C, P, T>
 		inherent_data: InherentData,
 		timestamp_now: u64,
 	) -> Result<(), Error<B>>
-		where C: ProvideRuntimeApi, C::Api: BlockBuilderApi<B, Error = client::error::Error>
+		where C: ProvideRuntimeApi, C::Api: BlockBuilderApi<B, Error = sp_blockchain::Error>
 	{
 		const MAX_TIMESTAMP_DRIFT_SECS: u64 = 60;
 
@@ -495,7 +498,7 @@ impl<C, P, T> AuraVerifier<C, P, T>
 #[forbid(deprecated)]
 impl<B: BlockT, C, P, T> Verifier<B> for AuraVerifier<C, P, T> where
 	C: ProvideRuntimeApi + Send + Sync + client_api::backend::AuxStore + ProvideCache<B> + BlockOf,
-	C::Api: BlockBuilderApi<B> + AuraApi<B, AuthorityId<P>> + ApiExt<B, Error = client::error::Error>,
+	C::Api: BlockBuilderApi<B> + AuraApi<B, AuthorityId<P>> + ApiExt<B, Error = sp_blockchain::Error>,
 	DigestItemFor<B>: CompatibleDigestItem<P>,
 	P: Pair + Send + Sync + 'static,
 	P::Public: Send + Sync + Hash + Eq + Clone + Decode + Encode + Debug + 'static,
@@ -682,7 +685,7 @@ pub fn import_queue<B, C, P, T>(
 ) -> Result<AuraImportQueue<B>, consensus_common::Error> where
 	B: BlockT,
 	C: 'static + ProvideRuntimeApi + BlockOf + ProvideCache<B> + Send + Sync + AuxStore,
-	C::Api: BlockBuilderApi<B> + AuraApi<B, AuthorityId<P>> + ApiExt<B, Error = client::error::Error>,
+	C::Api: BlockBuilderApi<B> + AuraApi<B, AuthorityId<P>> + ApiExt<B, Error = sp_blockchain::Error>,
 	DigestItemFor<B>: CompatibleDigestItem<P>,
 	P: Pair + Send + Sync + 'static,
 	P::Public: Clone + Eq + Send + Sync + Hash + Debug + Encode + Decode,
@@ -721,7 +724,7 @@ mod tests {
 	use test_client;
 	use aura_primitives::sr25519::AuthorityPair;
 
-	type Error = client::error::Error;
+	type Error = sp_blockchain::Error;
 
 	type TestClient = client::Client<
 		test_client::Backend,

substrate/client/consensus/babe/Cargo.toml

@@ -23,7 +23,7 @@ client-api = { package = "substrate-client-api", path = "../../api" }
 client = { package = "substrate-client", path = "../../" }
 sr-api = { path = "../../../primitives/sr-api" }
 block-builder-api = { package = "substrate-block-builder-runtime-api", path = "../../../primitives/block-builder/runtime-api" }
-header-metadata = { package = "substrate-header-metadata", path = "../../header-metadata" }
+sp-blockchain = { path = "../../../primitives/blockchain" }
 consensus-common = { package = "substrate-consensus-common", path = "../../../primitives/consensus/common" }
 uncles = { package = "substrate-consensus-uncles", path = "../uncles" }
 slots = { package = "substrate-consensus-slots", path = "../slots"  }

substrate/client/consensus/babe/src/aux_schema.rs

@@ -19,10 +19,8 @@
 use log::info;
 use codec::{Decode, Encode};
 
-use client_api::{
-	backend::AuxStore,
-	error::{Result as ClientResult, Error as ClientError},
-};
+use client_api::backend::AuxStore;
+use sp_blockchain::{Result as ClientResult, Error as ClientError};
 use sr_primitives::traits::Block as BlockT;
 use babe_primitives::BabeBlockWeight;
 

substrate/client/consensus/babe/src/epoch_changes.rs

@@ -25,12 +25,8 @@ use fork_tree::ForkTree;
 use parking_lot::{Mutex, MutexGuard};
 use sr_primitives::traits::{Block as BlockT, NumberFor, One, Zero};
 use codec::{Encode, Decode};
-use client_api::{
-	error::Error as ClientError,
-	utils::is_descendent_of,
-	blockchain::HeaderBackend
-};
-use header_metadata::HeaderMetadata;
+use client_api::utils::is_descendent_of;
+use sp_blockchain::{HeaderMetadata, HeaderBackend, Error as ClientError};
 use primitives::H256;
 use std::ops::Add;
 

substrate/client/consensus/babe/src/lib.rs

@@ -90,8 +90,6 @@ use consensus_common::import_queue::{Verifier, BasicQueue, CacheKeyId};
 use client_api::{
 	backend::{AuxStore, Backend},
 	call_executor::CallExecutor,
-	error::{Result as ClientResult, Error as ClientError},
-	blockchain::{self, HeaderBackend, ProvideCache},
 	BlockchainEvents, ProvideUncles,
 };
 use client::Client;
@@ -103,7 +101,10 @@ use futures::prelude::*;
 use log::{warn, debug, info, trace};
 use slots::{SlotWorker, SlotData, SlotInfo, SlotCompatible};
 use epoch_changes::descendent_query;
-use header_metadata::HeaderMetadata;
+use sp_blockchain::{
+	Result as ClientResult, Error as ClientError,
+	HeaderBackend, ProvideCache, HeaderMetadata
+};
 use schnorrkel::SignatureError;
 
 use sr_api::ApiExt;
@@ -157,11 +158,11 @@ enum Error<B: BlockT> {
 	#[display(fmt = "VRF verification failed: {:?}", _0)]
 	VRFVerificationFailed(SignatureError),
 	#[display(fmt = "Could not fetch parent header: {:?}", _0)]
-	FetchParentHeader(client_api::error::Error),
+	FetchParentHeader(sp_blockchain::Error),
 	#[display(fmt = "Expected epoch change to happen at {:?}, s{}", _0, _1)]
 	ExpectedEpochChange(B::Hash, u64),
 	#[display(fmt = "Could not look up epoch: {:?}", _0)]
-	CouldNotLookUpEpoch(Box<fork_tree::Error<client_api::error::Error>>),
+	CouldNotLookUpEpoch(Box<fork_tree::Error<sp_blockchain::Error>>),
 	#[display(fmt = "Block {} is not valid under any epoch.", _0)]
 	BlockNotValid(B::Hash),
 	#[display(fmt = "Unexpected epoch change")]
@@ -170,9 +171,9 @@ enum Error<B: BlockT> {
 	ParentBlockNoAssociatedWeight(B::Hash),
 	#[display(fmt = "Checking inherents failed: {}", _0)]
 	CheckInherents(String),
-	Client(client_api::error::Error),
+	Client(sp_blockchain::Error),
 	Runtime(inherents::Error),
-	ForkTree(Box<fork_tree::Error<client_api::error::Error>>),
+	ForkTree(Box<fork_tree::Error<sp_blockchain::Error>>),
 }
 
 impl<B: BlockT> std::convert::From<Error<B>> for String {
@@ -206,7 +207,7 @@ impl Config {
 	/// Either fetch the slot duration from disk or compute it from the genesis
 	/// state.
 	pub fn get_or_compute<B: BlockT, C>(client: &C) -> ClientResult<Self> where
-		C: AuxStore + ProvideRuntimeApi, C::Api: BabeApi<B, Error = client_api::error::Error>,
+		C: AuxStore + ProvideRuntimeApi, C::Api: BabeApi<B, Error = sp_blockchain::Error>,
 	{
 		trace!(target: "babe", "Getting slot duration");
 		match slots::SlotDuration::get_or_compute(client, |a, b| a.configuration(b)).map(Self) {
@@ -558,7 +559,7 @@ impl<B, E, Block: BlockT, RA, PRA> BabeVerifier<B, E, Block, RA, PRA> {
 		block_id: BlockId<Block>,
 		inherent_data: InherentData,
 	) -> Result<(), Error<Block>>
-		where PRA: ProvideRuntimeApi, PRA::Api: BlockBuilderApi<Block, Error = client_api::error::Error>
+		where PRA: ProvideRuntimeApi, PRA::Api: BlockBuilderApi<Block, Error = sp_blockchain::Error>
 	{
 		let inherent_res = self.api.runtime_api().check_inherents(
 			&block_id,
@@ -627,8 +628,8 @@ impl<B, E, Block, RA, PRA> Verifier<Block> for BabeVerifier<B, E, Block, RA, PRA
 	E: CallExecutor<Block, Blake2Hasher> + 'static + Clone + Send + Sync,
 	RA: Send + Sync,
 	PRA: ProvideRuntimeApi + Send + Sync + AuxStore + ProvideCache<Block>,
-	PRA::Api: BlockBuilderApi<Block, Error = client_api::error::Error>
-		+ BabeApi<Block, Error = client_api::error::Error>,
+	PRA::Api: BlockBuilderApi<Block, Error = sp_blockchain::Error>
+		+ BabeApi<Block, Error = sp_blockchain::Error>,
 {
 	fn verify(
 		&mut self,
@@ -851,8 +852,8 @@ impl<B, E, Block, I, RA, PRA> BlockImport<Block> for BabeBlockImport<B, E, Block
 		// early exit if block already in chain, otherwise the check for
 		// epoch changes will error when trying to re-import an epoch change
 		match self.client.status(BlockId::Hash(hash)) {
-			Ok(blockchain::BlockStatus::InChain) => return Ok(ImportResult::AlreadyInChain),
-			Ok(blockchain::BlockStatus::Unknown) => {},
+			Ok(sp_blockchain::BlockStatus::InChain) => return Ok(ImportResult::AlreadyInChain),
+			Ok(sp_blockchain::BlockStatus::Unknown) => {},
 			Err(e) => return Err(ConsensusError::ClientImport(e.to_string())),
 		}
 
@@ -907,7 +908,7 @@ impl<B, E, Block, I, RA, PRA> BlockImport<Block> for BabeBlockImport<B, E, Block
 				slot_number,
 				|slot| self.config.genesis_epoch(slot),
 			)
-				.map_err(|e: fork_tree::Error<client_api::error::Error>| ConsensusError::ChainLookup(
+				.map_err(|e: fork_tree::Error<sp_blockchain::Error>| ConsensusError::ChainLookup(
 					babe_err(Error::<Block>::CouldNotLookUpEpoch(Box::new(e))).into()
 				))?
 				.ok_or_else(|| ConsensusError::ClientImport(
@@ -1146,7 +1147,7 @@ pub fn import_queue<B, E, Block: BlockT<Hash=H256>, I, RA, PRA>(
 	E: CallExecutor<Block, Blake2Hasher> + Clone + Send + Sync + 'static,
 	RA: Send + Sync + 'static,
 	PRA: ProvideRuntimeApi + ProvideCache<Block> + Send + Sync + AuxStore + 'static,
-	PRA::Api: BlockBuilderApi<Block> + BabeApi<Block> + ApiExt<Block, Error = client_api::error::Error>,
+	PRA::Api: BlockBuilderApi<Block> + BabeApi<Block> + ApiExt<Block, Error = sp_blockchain::Error>,
 {
 	register_babe_inherent_data_provider(&inherent_data_providers, babe_link.config.slot_duration)?;
 

substrate/client/consensus/babe/src/tests.rs

@@ -41,7 +41,7 @@ use std::{time::Duration, cell::RefCell};
 
 type Item = DigestItem<Hash>;
 
-type Error = client::error::Error;
+type Error = sp_blockchain::Error;
 
 type TestClient = client::Client<
 	test_client::Backend,

substrate/client/consensus/pow/Cargo.toml

@@ -8,6 +8,7 @@ edition = "2018"
 [dependencies]
 codec = { package = "parity-scale-codec", version = "1.0.0", features = ["derive"] }
 primitives = { package = "substrate-primitives", path = "../../../primitives/core" }
+sp-blockchain = { path = "../../../primitives/blockchain" }
 sr-primitives = { path = "../../../primitives/sr-primitives" }
 client-api = { package = "substrate-client-api", path = "../../api" }
 block-builder-api = { package = "substrate-block-builder-runtime-api", path = "../../../primitives/block-builder/runtime-api" }

substrate/client/consensus/pow/src/lib.rs

@@ -32,10 +32,8 @@
 use std::sync::Arc;
 use std::thread;
 use std::collections::HashMap;
-use client_api::{
-	BlockOf, blockchain::{HeaderBackend, ProvideCache}, backend::AuxStore,
-	well_known_cache_keys::Id as CacheKeyId,
-};
+use client_api::{BlockOf, backend::AuxStore};
+use sp_blockchain::{HeaderBackend, ProvideCache, well_known_cache_keys::Id as CacheKeyId};
 use block_builder_api::BlockBuilder as BlockBuilderApi;
 use sr_primitives::{Justification, RuntimeString};
 use sr_primitives::generic::{BlockId, Digest, DigestItem};
@@ -66,7 +64,7 @@ pub enum Error<B: BlockT> {
 	#[display(fmt = "Fetching best header failed using select chain: {:?}", _0)]
 	BestHeaderSelectChain(ConsensusError),
 	#[display(fmt = "Fetching best header failed: {:?}", _0)]
-	BestHeader(client_api::error::Error),
+	BestHeader(sp_blockchain::Error),
 	#[display(fmt = "Best header does not exist")]
 	NoBestHeader,
 	#[display(fmt = "Block proposing error: {:?}", _0)]
@@ -79,7 +77,7 @@ pub enum Error<B: BlockT> {
 	CreateInherents(inherents::Error),
 	#[display(fmt = "Checking inherents failed: {}", _0)]
 	CheckInherents(String),
-	Client(client_api::error::Error),
+	Client(sp_blockchain::Error),
 	Codec(codec::Error),
 	Environment(String),
 	Runtime(RuntimeString)
@@ -211,7 +209,7 @@ impl<B: BlockT<Hash=H256>, C, S, Algorithm> PowVerifier<B, C, S, Algorithm> {
 		inherent_data: InherentData,
 		timestamp_now: u64,
 	) -> Result<(), Error<B>> where
-		C: ProvideRuntimeApi, C::Api: BlockBuilderApi<B, Error = client_api::error::Error>
+		C: ProvideRuntimeApi, C::Api: BlockBuilderApi<B, Error = sp_blockchain::Error>
 	{
 		const MAX_TIMESTAMP_DRIFT_SECS: u64 = 60;
 
@@ -249,7 +247,7 @@ impl<B: BlockT<Hash=H256>, C, S, Algorithm> PowVerifier<B, C, S, Algorithm> {
 
 impl<B: BlockT<Hash=H256>, C, S, Algorithm> Verifier<B> for PowVerifier<B, C, S, Algorithm> where
 	C: ProvideRuntimeApi + Send + Sync + HeaderBackend<B> + AuxStore + ProvideCache<B> + BlockOf,
-	C::Api: BlockBuilderApi<B, Error = client_api::error::Error>,
+	C::Api: BlockBuilderApi<B, Error = sp_blockchain::Error>,
 	S: SelectChain<B>,
 	Algorithm: PowAlgorithm<B> + Send + Sync,
 {
@@ -341,7 +339,7 @@ pub fn import_queue<B, C, S, Algorithm>(
 	B: BlockT<Hash=H256>,
 	C: ProvideRuntimeApi + HeaderBackend<B> + BlockOf + ProvideCache<B> + AuxStore,
 	C: Send + Sync + AuxStore + 'static,
-	C::Api: BlockBuilderApi<B, Error = client_api::error::Error>,
+	C::Api: BlockBuilderApi<B, Error = sp_blockchain::Error>,
 	Algorithm: PowAlgorithm<B> + Send + Sync + 'static,
 	S: SelectChain<B> + 'static,
 {

substrate/client/consensus/slots/Cargo.toml

@@ -10,6 +10,7 @@ build = "build.rs"
 codec = { package = "parity-scale-codec", version = "1.0.0" }
 client-api = { package = "substrate-client-api", path = "../../api" }
 primitives = { package = "substrate-primitives", path = "../../../primitives/core" }
+sp-blockchain = { path = "../../../primitives/blockchain" }
 sr-primitives = {  path = "../../../primitives/sr-primitives" }
 substrate-telemetry = { path = "../../telemetry" }
 consensus_common = { package = "substrate-consensus-common", path = "../../../primitives/consensus/common" }

substrate/client/consensus/slots/src/aux_schema.rs

@@ -18,7 +18,7 @@
 
 use codec::{Encode, Decode};
 use client_api::backend::AuxStore;
-use client_api::error::{Result as ClientResult, Error as ClientError};
+use sp_blockchain::{Result as ClientResult, Error as ClientError};
 use sr_primitives::traits::Header;
 
 const SLOT_HEADER_MAP_KEY: &[u8] = b"slot_header_map";

substrate/client/consensus/slots/src/lib.rs

@@ -401,17 +401,17 @@ impl<T: Clone> SlotDuration<T> {
 	///
 	/// `slot_key` is marked as `'static`, as it should really be a
 	/// compile-time constant.
-	pub fn get_or_compute<B: BlockT, C, CB>(client: &C, cb: CB) -> client_api::error::Result<Self> where
+	pub fn get_or_compute<B: BlockT, C, CB>(client: &C, cb: CB) -> sp_blockchain::Result<Self> where
 		C: client_api::backend::AuxStore,
 		C: ProvideRuntimeApi,
-		CB: FnOnce(ApiRef<C::Api>, &BlockId<B>) -> client_api::error::Result<T>,
+		CB: FnOnce(ApiRef<C::Api>, &BlockId<B>) -> sp_blockchain::Result<T>,
 		T: SlotData + Encode + Decode + Debug,
 	{
 		match client.get_aux(T::SLOT_KEY)? {
 			Some(v) => <T as codec::Decode>::decode(&mut &v[..])
 				.map(SlotDuration)
 				.map_err(|_| {
-					client_api::error::Error::Backend({
+					sp_blockchain::Error::Backend({
 						error!(target: "slots", "slot duration kept in invalid format");
 						"slot duration kept in invalid format".to_string()
 					})