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/db/src/cache/list_cache.rs

@@ -43,7 +43,7 @@ use std::collections::{BTreeSet, BTreeMap};
 
 use log::warn;
 
-use client_api::error::{Error as ClientError, Result as ClientResult};
+use sp_blockchain::{Error as ClientError, Result as ClientResult};
 use sr_primitives::traits::{
 	Block as BlockT, NumberFor, Zero, Bounded, CheckedSub
 };

substrate/client/db/src/cache/list_entry.rs

@@ -16,7 +16,7 @@
 
 //! List-cache storage entries.
 
-use client_api::error::Result as ClientResult;
+use sp_blockchain::Result as ClientResult;
 use sr_primitives::traits::{Block as BlockT, NumberFor};
 use codec::{Encode, Decode};
 

substrate/client/db/src/cache/list_storage.rs

@@ -20,7 +20,7 @@ use std::sync::Arc;
 
 use kvdb::{KeyValueDB, DBTransaction};
 
-use client_api::error::{Error as ClientError, Result as ClientResult};
+use sp_blockchain::{Error as ClientError, Result as ClientResult};
 use codec::{Encode, Decode};
 use sr_primitives::generic::BlockId;
 use sr_primitives::traits::{Block as BlockT, Header as HeaderT, NumberFor};

substrate/client/db/src/cache/mod.rs

@@ -22,7 +22,7 @@ use parking_lot::RwLock;
 use kvdb::{KeyValueDB, DBTransaction};
 
 use client_api::blockchain::{well_known_cache_keys::{self, Id as CacheKeyId}, Cache as BlockchainCache};
-use client_api::error::Result as ClientResult;
+use sp_blockchain::Result as ClientResult;
 use codec::{Encode, Decode};
 use sr_primitives::generic::BlockId;
 use sr_primitives::traits::{Block as BlockT, Header as HeaderT, NumberFor, Zero};
@@ -211,7 +211,7 @@ impl<'a, Block: BlockT> DbCacheTransaction<'a, Block> {
 			.cloned()
 			.collect::<Vec<_>>();
 
-		let mut insert_op = |name: CacheKeyId, value: Option<Vec<u8>>| -> Result<(), client_api::error::Error> {
+		let mut insert_op = |name: CacheKeyId, value: Option<Vec<u8>>| -> Result<(), sp_blockchain::Error> {
 			let cache = self.cache.get_cache(name);
 			let op = cache.on_block_insert(
 				&mut self::list_storage::DbStorageTransaction::new(

substrate/client/db/src/children.rs

@@ -18,7 +18,7 @@
 
 use kvdb::{KeyValueDB, DBTransaction};
 use codec::{Encode, Decode};
-use client_api::error;
+use sp_blockchain;
 use std::hash::Hash;
 
 
@@ -26,13 +26,13 @@ use std::hash::Hash;
 pub fn read_children<
 	K: Eq + Hash + Clone + Encode + Decode,
 	V: Eq + Hash + Clone + Encode + Decode,
->(db: &dyn KeyValueDB, column: Option<u32>, prefix: &[u8], parent_hash: K) -> error::Result<Vec<V>> {
+>(db: &dyn KeyValueDB, column: Option<u32>, prefix: &[u8], parent_hash: K) -> sp_blockchain::Result<Vec<V>> {
 	let mut buf = prefix.to_vec();
 	parent_hash.using_encoded(|s| buf.extend(s));
 
 	let raw_val_opt = match db.get(column, &buf[..]) {
 		Ok(raw_val_opt) => raw_val_opt,
-		Err(_) => return Err(error::Error::Backend("Error reading value from database".into())),
+		Err(_) => return Err(sp_blockchain::Error::Backend("Error reading value from database".into())),
 	};
 
 	let raw_val = match raw_val_opt {
@@ -42,7 +42,7 @@ pub fn read_children<
 
 	let children: Vec<V> = match Decode::decode(&mut &raw_val[..]) {
 		Ok(children) => children,
-		Err(_) => return Err(error::Error::Backend("Error decoding children".into())),
+		Err(_) => return Err(sp_blockchain::Error::Backend("Error decoding children".into())),
 	};
 
 	Ok(children)

substrate/client/db/src/lib.rs

@@ -39,12 +39,13 @@ use std::path::PathBuf;
 use std::io;
 use std::collections::{HashMap, HashSet};
 
-use client_api::ForkBlocks;
+use client_api::{execution_extensions::ExecutionExtensions, ForkBlocks};
 use client_api::backend::NewBlockState;
 use client_api::backend::{StorageCollection, ChildStorageCollection};
-use client_api::blockchain::{well_known_cache_keys, HeaderBackend};
-use client_api::error::{Result as ClientResult, Error as ClientError};
-use client_api::execution_extensions::ExecutionExtensions;
+use sp_blockchain::{
+	Result as ClientResult, Error as ClientError,
+	well_known_cache_keys, HeaderBackend,
+};
 use codec::{Decode, Encode};
 use hash_db::{Hasher, Prefix};
 use kvdb::{KeyValueDB, DBTransaction};
@@ -67,7 +68,7 @@ use state_machine::{
 use crate::utils::{Meta, db_err, meta_keys, read_db, read_meta};
 use client::leaves::{LeafSet, FinalizationDisplaced};
 use state_db::StateDb;
-use header_metadata::{CachedHeaderMetadata, HeaderMetadata, HeaderMetadataCache};
+use sp_blockchain::{CachedHeaderMetadata, HeaderMetadata, HeaderMetadataCache};
 use crate::storage_cache::{CachingState, SharedCache, new_shared_cache};
 use log::{trace, debug, warn};
 pub use state_db::PruningMode;
@@ -239,7 +240,7 @@ pub fn new_client<E, S, Block, RA>(
 		>,
 		Arc<Backend<Block>>,
 	),
-	client::error::Error,
+	sp_blockchain::Error,
 >
 	where
 		Block: BlockT<Hash=H256>,
@@ -381,7 +382,7 @@ impl<Block: BlockT> client::blockchain::Backend<Block> for BlockchainDb<Block> {
 		match read_db(&*self.db, columns::KEY_LOOKUP, columns::BODY, id)? {
 			Some(body) => match Decode::decode(&mut &body[..]) {
 				Ok(body) => Ok(Some(body)),
-				Err(err) => return Err(client::error::Error::Backend(
+				Err(err) => return Err(sp_blockchain::Error::Backend(
 					format!("Error decoding body: {}", err)
 				)),
 			}
@@ -393,7 +394,7 @@ impl<Block: BlockT> client::blockchain::Backend<Block> for BlockchainDb<Block> {
 		match read_db(&*self.db, columns::KEY_LOOKUP, columns::JUSTIFICATION, id)? {
 			Some(justification) => match Decode::decode(&mut &justification[..]) {
 				Ok(justification) => Ok(Some(justification)),
-				Err(err) => return Err(client::error::Error::Backend(
+				Err(err) => return Err(sp_blockchain::Error::Backend(
 					format!("Error decoding justification: {}", err)
 				)),
 			}
@@ -425,7 +426,7 @@ impl<Block: BlockT> client::blockchain::ProvideCache<Block> for BlockchainDb<Blo
 }
 
 impl<Block: BlockT> HeaderMetadata<Block> for BlockchainDb<Block> {
-	type Error = client::error::Error;
+	type Error = sp_blockchain::Error;
 
 	fn header_metadata(&self, hash: Block::Hash) -> Result<CachedHeaderMetadata<Block>, Self::Error> {
 		self.header_metadata_cache.header_metadata(hash).or_else(|_| {
@@ -517,12 +518,12 @@ impl<Block> client_api::backend::BlockImportOperation<Block, Blake2Hasher>
 	) -> ClientResult<H256> {
 
 		if top.iter().any(|(k, _)| well_known_keys::is_child_storage_key(k)) {
-			return Err(client::error::Error::GenesisInvalid.into());
+			return Err(sp_blockchain::Error::GenesisInvalid.into());
 		}
 
 		for child_key in children.keys() {
 			if !well_known_keys::is_child_storage_key(&child_key) {
-				return Err(client::error::Error::GenesisInvalid.into());
+				return Err(sp_blockchain::Error::GenesisInvalid.into());
 			}
 		}
 
@@ -823,7 +824,7 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 		let is_archive_pruning = config.pruning.is_archive();
 		let blockchain = BlockchainDb::new(db.clone())?;
 		let meta = blockchain.meta.clone();
-		let map_e = |e: state_db::Error<io::Error>| ::client::error::Error::from(format!("State database error: {:?}", e));
+		let map_e = |e: state_db::Error<io::Error>| ::sp_blockchain::Error::from(format!("State database error: {:?}", e));
 		let state_db: StateDb<_, _> = StateDb::new(config.pruning.clone(), &StateMetaDb(&*db)).map_err(map_e)?;
 		let storage_db = StorageDb {
 			db: db.clone(),
@@ -948,7 +949,7 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 
 		// cannot find tree route with empty DB.
 		if meta.best_hash != Default::default() {
-			let tree_route = header_metadata::tree_route(
+			let tree_route = sp_blockchain::tree_route(
 				&self.blockchain,
 				meta.best_hash,
 				route_to,
@@ -963,7 +964,7 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 						(&r.number, &r.hash)
 					);
 
-					return Err(::client::error::Error::NotInFinalizedChain.into());
+					return Err(::sp_blockchain::Error::NotInFinalizedChain.into());
 				}
 
 				retracted.push(r.hash.clone());
@@ -1005,7 +1006,7 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 	) -> ClientResult<()> {
 		let last_finalized = last_finalized.unwrap_or_else(|| self.blockchain.meta.read().finalized_hash);
 		if *header.parent_hash() != last_finalized {
-			return Err(::client::error::Error::NonSequentialFinalization(
+			return Err(::sp_blockchain::Error::NonSequentialFinalization(
 				format!("Last finalized {:?} not parent of {:?}", last_finalized, header.hash()),
 			).into());
 		}
@@ -1068,7 +1069,7 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 
 			trace!(target: "db", "Canonicalize block #{} ({:?})", new_canonical, hash);
 			let commit = self.storage.state_db.canonicalize_block(&hash)
-				.map_err(|e: state_db::Error<io::Error>| client::error::Error::from(format!("State database error: {:?}", e)))?;
+				.map_err(|e: state_db::Error<io::Error>| sp_blockchain::Error::from(format!("State database error: {:?}", e)))?;
 			apply_state_commit(transaction, commit);
 		};
 
@@ -1152,7 +1153,7 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 				}
 				let number_u64 = number.saturated_into::<u64>();
 				let commit = self.storage.state_db.insert_block(&hash, number_u64, &pending_block.header.parent_hash(), changeset)
-					.map_err(|e: state_db::Error<io::Error>| client::error::Error::from(format!("State database error: {:?}", e)))?;
+					.map_err(|e: state_db::Error<io::Error>| sp_blockchain::Error::from(format!("State database error: {:?}", e)))?;
 				apply_state_commit(&mut transaction, commit);
 
 				// Check if need to finalize. Genesis is always finalized instantly.
@@ -1217,7 +1218,7 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 				meta_updates.push((hash, *number, true, false));
 				Some((enacted, retracted))
 			} else {
-				return Err(client::error::Error::UnknownBlock(format!("Cannot set head {:?}", set_head)))
+				return Err(sp_blockchain::Error::UnknownBlock(format!("Cannot set head {:?}", set_head)))
 			}
 		} else {
 			None
@@ -1288,7 +1289,7 @@ impl<Block: BlockT<Hash=H256>> Backend<Block> {
 			transaction.put(columns::META, meta_keys::FINALIZED_BLOCK, &lookup_key);
 
 			let commit = self.storage.state_db.canonicalize_block(&f_hash)
-				.map_err(|e: state_db::Error<io::Error>| client::error::Error::from(format!("State database error: {:?}", e)))?;
+				.map_err(|e: state_db::Error<io::Error>| sp_blockchain::Error::from(format!("State database error: {:?}", e)))?;
 			apply_state_commit(transaction, commit);
 
 			let changes_trie_config = self.changes_trie_config(parent_hash)?;
@@ -1451,12 +1452,12 @@ impl<Block> client_api::backend::Backend<Block, Blake2Hasher> for Backend<Block>
 				Some(commit) => {
 					apply_state_commit(&mut transaction, commit);
 					let removed = self.blockchain.header(BlockId::Number(best))?.ok_or_else(
-						|| client::error::Error::UnknownBlock(
+						|| sp_blockchain::Error::UnknownBlock(
 							format!("Error reverting to {}. Block hash not found.", best)))?;
 
 					best -= One::one();	// prev block
 					let hash = self.blockchain.hash(best)?.ok_or_else(
-						|| client::error::Error::UnknownBlock(
+						|| sp_blockchain::Error::UnknownBlock(
 							format!("Error reverting to {}. Block hash not found.", best)))?;
 					let key = utils::number_and_hash_to_lookup_key(best.clone(), &hash)?;
 					transaction.put(columns::META, meta_keys::BEST_BLOCK, &key);
@@ -1500,7 +1501,7 @@ impl<Block> client_api::backend::Backend<Block, Blake2Hasher> for Backend<Block>
 			Ok(Some(ref hdr)) => {
 				let hash = hdr.hash();
 				if !self.have_state_at(&hash, *hdr.number()) {
-					return Err(client::error::Error::UnknownBlock(format!("State already discarded for {:?}", block)))
+					return Err(sp_blockchain::Error::UnknownBlock(format!("State already discarded for {:?}", block)))
 				}
 				if let Ok(()) = self.storage.state_db.pin(&hash) {
 					let root = H256::from_slice(hdr.state_root().as_ref());
@@ -1508,10 +1509,10 @@ impl<Block> client_api::backend::Backend<Block, Blake2Hasher> for Backend<Block>
 					let state = RefTrackingState::new(db_state, self.storage.clone(), Some(hash.clone()));
 					Ok(CachingState::new(state, self.shared_cache.clone(), Some(hash)))
 				} else {
-					Err(client::error::Error::UnknownBlock(format!("State already discarded for {:?}", block)))
+					Err(sp_blockchain::Error::UnknownBlock(format!("State already discarded for {:?}", block)))
 				}
 			},
-			Ok(None) => Err(client::error::Error::UnknownBlock(format!("Unknown state for block {:?}", block))),
+			Ok(None) => Err(sp_blockchain::Error::UnknownBlock(format!("Unknown state for block {:?}", block))),
 			Err(e) => Err(e),
 		}
 	}
@@ -1561,7 +1562,7 @@ mod tests {
 	use sr_primitives::testing::{Header, Block as RawBlock, ExtrinsicWrapper};
 	use sr_primitives::traits::{Hash, BlakeTwo256};
 	use state_machine::{TrieMut, TrieDBMut, ChangesTrieRootsStorage, ChangesTrieStorage};
-	use header_metadata::{lowest_common_ancestor, tree_route};
+	use sp_blockchain::{lowest_common_ancestor, tree_route};
 
 	use test_client;
 

substrate/client/db/src/light.rs

@@ -24,18 +24,20 @@ use kvdb::{KeyValueDB, DBTransaction};
 
 use client_api::backend::{AuxStore, NewBlockState};
 use client::blockchain::{
-	BlockStatus, Cache as BlockchainCache,
-	HeaderBackend as BlockchainHeaderBackend, Info as BlockchainInfo,
-	well_known_cache_keys,
+	BlockStatus, Cache as BlockchainCache,Info as BlockchainInfo,
 };
 use client::cht;
-use client::error::{Error as ClientError, Result as ClientResult};
+use sp_blockchain::{
+	CachedHeaderMetadata, HeaderMetadata, HeaderMetadataCache,
+	Error as ClientError, Result as ClientResult,
+	HeaderBackend as BlockchainHeaderBackend, 
+	well_known_cache_keys,
+};
 use client::light::blockchain::Storage as LightBlockchainStorage;
 use codec::{Decode, Encode};
 use primitives::Blake2Hasher;
 use sr_primitives::generic::{DigestItem, BlockId};
 use sr_primitives::traits::{Block as BlockT, Header as HeaderT, Zero, One, NumberFor};
-use header_metadata::{CachedHeaderMetadata, HeaderMetadata, HeaderMetadataCache};
 use crate::cache::{DbCacheSync, DbCache, ComplexBlockId, EntryType as CacheEntryType};
 use crate::utils::{self, meta_keys, Meta, db_err, read_db, block_id_to_lookup_key, read_meta};
 use crate::DatabaseSettings;
@@ -235,7 +237,7 @@ impl<Block: BlockT> LightStorage<Block> {
 		// handle reorg.
 		let meta = self.meta.read();
 		if meta.best_hash != Default::default() {
-			let tree_route = header_metadata::tree_route(self, meta.best_hash, route_to)?;
+			let tree_route = sp_blockchain::tree_route(self, meta.best_hash, route_to)?;
 
 			// update block number to hash lookup entries.
 			for retracted in tree_route.retracted() {
@@ -282,7 +284,7 @@ impl<Block: BlockT> LightStorage<Block> {
 	) -> ClientResult<()> {
 		let meta = self.meta.read();
 		if &meta.finalized_hash != header.parent_hash() {
-			return Err(::client::error::Error::NonSequentialFinalization(
+			return Err(::sp_blockchain::Error::NonSequentialFinalization(
 				format!("Last finalized {:?} not parent of {:?}",
 					meta.finalized_hash, hash),
 			).into())
@@ -560,7 +562,7 @@ pub(crate) mod tests {
 	use client::cht;
 	use sr_primitives::generic::DigestItem;
 	use sr_primitives::testing::{H256 as Hash, Header, Block as RawBlock, ExtrinsicWrapper};
-	use header_metadata::{lowest_common_ancestor, tree_route};
+	use sp_blockchain::{lowest_common_ancestor, tree_route};
 	use super::*;
 
 	type Block = RawBlock<ExtrinsicWrapper<u32>>;

substrate/client/db/src/utils.rs

@@ -25,7 +25,6 @@ use kvdb::{KeyValueDB, DBTransaction};
 use kvdb_rocksdb::{Database, DatabaseConfig};
 use log::debug;
 
-use client;
 use codec::Decode;
 use trie::DBValue;
 use sr_primitives::generic::BlockId;
@@ -82,9 +81,9 @@ pub type NumberIndexKey = [u8; 4];
 ///
 /// In the current database schema, this kind of key is only used for
 /// lookups into an index, NOT for storing header data or others.
-pub fn number_index_key<N: TryInto<u32>>(n: N) -> client::error::Result<NumberIndexKey> {
+pub fn number_index_key<N: TryInto<u32>>(n: N) -> sp_blockchain::Result<NumberIndexKey> {
 	let n = n.try_into().map_err(|_|
-		client::error::Error::Backend("Block number cannot be converted to u32".into())
+		sp_blockchain::Error::Backend("Block number cannot be converted to u32".into())
 	)?;
 
 	Ok([
@@ -100,7 +99,7 @@ pub fn number_index_key<N: TryInto<u32>>(n: N) -> client::error::Result<NumberIn
 pub fn number_and_hash_to_lookup_key<N, H>(
 	number: N,
 	hash: H,
-) -> client::error::Result<Vec<u8>>	where
+) -> sp_blockchain::Result<Vec<u8>>	where
 	N: TryInto<u32>,
 	H: AsRef<[u8]>,
 {
@@ -111,11 +110,11 @@ pub fn number_and_hash_to_lookup_key<N, H>(
 
 /// Convert block lookup key into block number.
 /// all block lookup keys start with the block number.
-pub fn lookup_key_to_number<N>(key: &[u8]) -> client::error::Result<N> where
+pub fn lookup_key_to_number<N>(key: &[u8]) -> sp_blockchain::Result<N> where
 	N: From<u32>
 {
 	if key.len() < 4 {
-		return Err(client::error::Error::Backend("Invalid block key".into()));
+		return Err(sp_blockchain::Error::Backend("Invalid block key".into()));
 	}
 	Ok((key[0] as u32) << 24
 		| (key[1] as u32) << 16
@@ -128,7 +127,7 @@ pub fn remove_number_to_key_mapping<N: TryInto<u32>>(
 	transaction: &mut DBTransaction,
 	key_lookup_col: Option<u32>,
 	number: N,
-) -> client::error::Result<()> {
+) -> sp_blockchain::Result<()> {
 	transaction.delete(key_lookup_col, number_index_key(number)?.as_ref());
 	Ok(())
 }
@@ -139,7 +138,7 @@ pub fn remove_key_mappings<N: TryInto<u32>, H: AsRef<[u8]>>(
 	key_lookup_col: Option<u32>,
 	number: N,
 	hash: H,
-) -> client::error::Result<()> {
+) -> sp_blockchain::Result<()> {
 	remove_number_to_key_mapping(transaction, key_lookup_col, number)?;
 	transaction.delete(key_lookup_col, hash.as_ref());
 	Ok(())
@@ -152,7 +151,7 @@ pub fn insert_number_to_key_mapping<N: TryInto<u32> + Clone, H: AsRef<[u8]>>(
 	key_lookup_col: Option<u32>,
 	number: N,
 	hash: H,
-) -> client::error::Result<()> {
+) -> sp_blockchain::Result<()> {
 	transaction.put_vec(
 		key_lookup_col,
 		number_index_key(number.clone())?.as_ref(),
@@ -167,7 +166,7 @@ pub fn insert_hash_to_key_mapping<N: TryInto<u32>, H: AsRef<[u8]> + Clone>(
 	key_lookup_col: Option<u32>,
 	number: N,
 	hash: H,
-) -> client::error::Result<()> {
+) -> sp_blockchain::Result<()> {
 	transaction.put_vec(
 		key_lookup_col,
 		hash.clone().as_ref(),
@@ -183,7 +182,7 @@ pub fn block_id_to_lookup_key<Block>(
 	db: &dyn KeyValueDB,
 	key_lookup_col: Option<u32>,
 	id: BlockId<Block>
-) -> Result<Option<Vec<u8>>, client::error::Error> where
+) -> Result<Option<Vec<u8>>, sp_blockchain::Error> where
 	Block: BlockT,
 	::sr_primitives::traits::NumberFor<Block>: UniqueSaturatedFrom<u64> + UniqueSaturatedInto<u64>,
 {
@@ -199,8 +198,8 @@ pub fn block_id_to_lookup_key<Block>(
 }
 
 /// Maps database error to client error
-pub fn db_err(err: io::Error) -> client::error::Error {
-	client::error::Error::Backend(format!("{}", err))
+pub fn db_err(err: io::Error) -> sp_blockchain::Error {
+	sp_blockchain::Error::Backend(format!("{}", err))
 }
 
 /// Open RocksDB database.
@@ -208,7 +207,7 @@ pub fn open_database(
 	config: &DatabaseSettings,
 	col_meta: Option<u32>,
 	db_type: &str
-) -> client::error::Result<Arc<dyn KeyValueDB>> {
+) -> sp_blockchain::Result<Arc<dyn KeyValueDB>> {
 	let db: Arc<dyn KeyValueDB> = match &config.source {
 		#[cfg(feature = "kvdb-rocksdb")]
 		DatabaseSettingsSrc::Path { path, cache_size } => {
@@ -230,13 +229,13 @@ pub fn open_database(
 				db_config.memory_budget = memory_budget;
 			}
 			let path = path.to_str()
-				.ok_or_else(|| client::error::Error::Backend("Invalid database path".into()))?;
+				.ok_or_else(|| sp_blockchain::Error::Backend("Invalid database path".into()))?;
 			Arc::new(Database::open(&db_config, &path).map_err(db_err)?)
 		},
 		#[cfg(not(feature = "kvdb-rocksdb"))]
 		DatabaseSettingsSrc::Path { .. } => {
 			let msg = "Try to open RocksDB database with RocksDB disabled".into();
-			return Err(client::error::Error::Backend(msg));
+			return Err(sp_blockchain::Error::Backend(msg));
 		},
 		DatabaseSettingsSrc::Custom(db) => db.clone(),
 	};
@@ -245,7 +244,7 @@ pub fn open_database(
 	match db.get(col_meta, meta_keys::TYPE).map_err(db_err)? {
 		Some(stored_type) => {
 			if db_type.as_bytes() != &*stored_type {
-				return Err(client::error::Error::Backend(
+				return Err(sp_blockchain::Error::Backend(
 					format!("Unexpected database type. Expected: {}", db_type)).into());
 			}
 		},
@@ -265,7 +264,7 @@ pub fn read_db<Block>(
 	col_index: Option<u32>,
 	col: Option<u32>,
 	id: BlockId<Block>
-) -> client::error::Result<Option<DBValue>>
+) -> sp_blockchain::Result<Option<DBValue>>
 	where
 		Block: BlockT,
 {
@@ -281,12 +280,12 @@ pub fn read_header<Block: BlockT>(
 	col_index: Option<u32>,
 	col: Option<u32>,
 	id: BlockId<Block>,
-) -> client::error::Result<Option<Block::Header>> {
+) -> sp_blockchain::Result<Option<Block::Header>> {
 	match read_db(db, col_index, col, id)? {
 		Some(header) => match Block::Header::decode(&mut &header[..]) {
 			Ok(header) => Ok(Some(header)),
 			Err(_) => return Err(
-				client::error::Error::Backend("Error decoding header".into())
+				sp_blockchain::Error::Backend("Error decoding header".into())
 			),
 		}
 		None => Ok(None),
@@ -299,15 +298,15 @@ pub fn require_header<Block: BlockT>(
 	col_index: Option<u32>,
 	col: Option<u32>,
 	id: BlockId<Block>,
-) -> client::error::Result<Block::Header> {
+) -> sp_blockchain::Result<Block::Header> {
 	read_header(db, col_index, col, id)
-		.and_then(|header| header.ok_or_else(|| client::error::Error::UnknownBlock(format!("{}", id))))
+		.and_then(|header| header.ok_or_else(|| sp_blockchain::Error::UnknownBlock(format!("{}", id))))
 }
 
 /// Read meta from the database.
 pub fn read_meta<Block>(db: &dyn KeyValueDB, col_meta: Option<u32>, col_header: Option<u32>) -> Result<
 	Meta<<<Block as BlockT>::Header as HeaderT>::Number, Block::Hash>,
-	client::error::Error,
+	sp_blockchain::Error,
 >
 	where
 		Block: BlockT,
@@ -315,7 +314,7 @@ pub fn read_meta<Block>(db: &dyn KeyValueDB, col_meta: Option<u32>, col_header:
 	let genesis_hash: Block::Hash = match db.get(col_meta, meta_keys::GENESIS_HASH).map_err(db_err)? {
 		Some(h) => match Decode::decode(&mut &h[..]) {
 			Ok(h) => h,
-			Err(err) => return Err(client::error::Error::Backend(
+			Err(err) => return Err(sp_blockchain::Error::Backend(
 				format!("Error decoding genesis hash: {}", err)
 			)),
 		},
@@ -328,7 +327,7 @@ pub fn read_meta<Block>(db: &dyn KeyValueDB, col_meta: Option<u32>, col_header:
 		}),
 	};
 
-	let load_meta_block = |desc, key| -> Result<_, client::error::Error> {
+	let load_meta_block = |desc, key| -> Result<_, sp_blockchain::Error> {
 		if let Some(Some(header)) = db.get(col_meta, key).and_then(|id|
 			match id {
 				Some(id) => db.get(col_header, &id).map(|h| h.map(|b| Block::Header::decode(&mut &b[..]).ok())),