removes use of sc_client::Client from sc_network (#5147)

* removes use of sc_client::Client from sc_network

* rename BlockProvider to BlockBackend

* fix broken test

substrate/bin/node/inspect/src/lib.rs

@@ -30,7 +30,7 @@ use std::{
 	marker::PhantomData
 };
 use codec::{Encode, Decode};
-use sc_client_api::BlockBody;
+use sc_client_api::BlockBackend;
 use sp_blockchain::HeaderBackend;
 use sp_core::hexdisplay::HexDisplay;
 use sp_runtime::{
@@ -101,12 +101,12 @@ impl std::error::Error for Error {
 /// A helper trait to access block headers and bodies.
 pub trait ChainAccess<TBlock: Block>:
 	HeaderBackend<TBlock> +
-	BlockBody<TBlock>
+	BlockBackend<TBlock>
 {}
 
 impl<T, TBlock> ChainAccess<TBlock> for T where
 	TBlock: Block,
-	T: sp_blockchain::HeaderBackend<TBlock> + sc_client_api::BlockBody<TBlock>,
+	T: sp_blockchain::HeaderBackend<TBlock> + sc_client_api::BlockBackend<TBlock>,
 {}
 
 /// Blockchain inspector.

substrate/client/api/src/call_executor.rs

@@ -35,6 +35,7 @@ use crate::execution_extensions::ExecutionExtensions;
 pub trait ExecutorProvider<Block: BlockT> {
 	/// executor instance
 	type Executor: CallExecutor<Block>;
+
 	/// Get call executor reference.
 	fn executor(&self) -> &Self::Executor;
 

substrate/client/api/src/client.rs

@@ -21,7 +21,8 @@ use futures::channel::mpsc;
 use sp_core::storage::StorageKey;
 use sp_runtime::{
 	traits::{Block as BlockT, NumberFor},
-	generic::{BlockId, SignedBlock}
+	generic::{BlockId, SignedBlock},
+	Justification,
 };
 use sp_consensus::BlockOrigin;
 
@@ -73,8 +74,8 @@ pub trait BlockchainEvents<Block: BlockT> {
 	) -> sp_blockchain::Result<StorageEventStream<Block::Hash>>;
 }
 
-/// Fetch block body by ID.
-pub trait BlockBody<Block: BlockT> {
+/// Interface for fetching block data.
+pub trait BlockBackend<Block: BlockT> {
 	/// Get block body by ID. Returns `None` if the body is not stored.
 	fn block_body(
 		&self,
@@ -83,6 +84,12 @@ pub trait BlockBody<Block: BlockT> {
 
 	/// Get full block by id.
 	fn block(&self, id: &BlockId<Block>) -> sp_blockchain::Result<Option<SignedBlock<Block>>>;
+
+	/// Get block status.
+	fn block_status(&self, id: &BlockId<Block>) -> sp_blockchain::Result<sp_consensus::BlockStatus>;
+
+	/// Get block justification set by id.
+	fn justification(&self, id: &BlockId<Block>) -> sp_blockchain::Result<Option<Justification>>;
 }
 
 /// Provide a list of potential uncle headers for a given block.

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

@@ -50,8 +50,6 @@ pub trait BabeApi {
 }
 
 /// Implements the BabeRPC trait for interacting with Babe.
-///
-/// Uses a background thread to calculate epoch_authorship data.
 pub struct BabeRPCHandler<B: BlockT, C, SC> {
 	/// shared reference to the client.
 	client: Arc<C>,
@@ -74,7 +72,6 @@ impl<B: BlockT, C, SC> BabeRPCHandler<B, C, SC> {
 		babe_config: Config,
 		select_chain: SC,
 	) -> Self {
-
 		Self {
 			client,
 			shared_epoch_changes,

substrate/client/network/src/chain.rs

@@ -16,77 +16,20 @@
 
 //! Blockchain access trait
 
-use sc_client::Client as SubstrateClient;
-use sp_blockchain::{Error, Info as BlockchainInfo};
-use sc_client_api::{ChangesProof, StorageProof, CallExecutor, ProofProvider};
-use sp_consensus::{BlockImport, BlockStatus, Error as ConsensusError};
-use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor};
-use sp_runtime::generic::{BlockId};
-use sp_runtime::Justification;
-use sp_core::storage::{StorageKey, ChildInfo};
+use sp_blockchain::{Error, HeaderBackend, HeaderMetadata};
+use sc_client_api::{BlockBackend, ProofProvider};
+use sp_runtime::traits::{Block as BlockT, BlockIdTo};
 
 /// Local client abstraction for the network.
-pub trait Client<Block: BlockT>: Send + Sync {
-	/// Get blockchain info.
-	fn info(&self) -> BlockchainInfo<Block>;
+pub trait Client<Block: BlockT>: HeaderBackend<Block> + ProofProvider<Block> + BlockIdTo<Block, Error = Error>
+	+ BlockBackend<Block> + HeaderMetadata<Block, Error = Error> + Send + Sync
+{}
 
-	/// Get block status.
-	fn block_status(&self, id: &BlockId<Block>) -> Result<BlockStatus, Error>;
-
-	/// Get block hash by number.
-	fn block_hash(&self, block_number: NumberFor<Block>) -> Result<Option<Block::Hash>, Error>;
-
-	/// Get block header.
-	fn header(&self, id: &BlockId<Block>) -> Result<Option<Block::Header>, Error>;
-
-	/// Get block body.
-	fn body(&self, id: &BlockId<Block>) -> Result<Option<Vec<Block::Extrinsic>>, Error>;
-
-	/// Get block justification.
-	fn justification(&self, id: &BlockId<Block>) -> Result<Option<Justification>, Error>;
-
-	/// Get block header proof.
-	fn header_proof(&self, block_number: NumberFor<Block>)
-		-> Result<(Block::Header, StorageProof), Error>;
-
-	/// Get storage read execution proof.
-	fn read_proof(
-		&self,
-		block: &Block::Hash,
-		keys: &mut dyn Iterator<Item=&[u8]>,
-	) -> Result<StorageProof, Error>;
-
-	/// Get child storage read execution proof.
-	fn read_child_proof(
-		&self,
-		block: &Block::Hash,
-		storage_key: &[u8],
-		child_info: ChildInfo,
-		keys: &mut dyn Iterator<Item=&[u8]>,
-	) -> Result<StorageProof, Error>;
-
-	/// Get method execution proof.
-	fn execution_proof(
-		&self,
-		block: &Block::Hash,
-		method: &str,
-		data: &[u8],
-	) -> Result<(Vec<u8>, StorageProof), Error>;
-
-	/// Get key changes proof.
-	fn key_changes_proof(
-		&self,
-		first: Block::Hash,
-		last: Block::Hash,
-		min: Block::Hash,
-		max: Block::Hash,
-		storage_key: Option<&StorageKey>,
-		key: &StorageKey
-	) -> Result<ChangesProof<Block::Header>, Error>;
-
-	/// Returns `true` if the given `block` is a descendent of `base`.
-	fn is_descendent_of(&self, base: &Block::Hash, block: &Block::Hash) -> Result<bool, Error>;
-}
+impl<Block: BlockT, T> Client<Block> for T
+	where
+		T: HeaderBackend<Block> + ProofProvider<Block> + BlockIdTo<Block, Error = Error>
+			+ BlockBackend<Block> + HeaderMetadata<Block, Error = Error> + Send + Sync
+{}
 
 /// Finality proof provider.
 pub trait FinalityProofProvider<Block: BlockT>: Send + Sync {
@@ -99,99 +42,3 @@ impl<Block: BlockT> FinalityProofProvider<Block> for () {
 		Ok(None)
 	}
 }
-
-impl<B, E, Block, RA> Client<Block> for SubstrateClient<B, E, Block, RA> where
-	B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
-	E: CallExecutor<Block> + Send + Sync + 'static,
-	Self: BlockImport<Block, Error=ConsensusError>,
-	Block: BlockT,
-	RA: Send + Sync
-{
-	fn info(&self) -> BlockchainInfo<Block> {
-		(self as &SubstrateClient<B, E, Block, RA>).chain_info()
-	}
-
-	fn block_status(&self, id: &BlockId<Block>) -> Result<BlockStatus, Error> {
-		(self as &SubstrateClient<B, E, Block, RA>).block_status(id)
-	}
-
-	fn block_hash(
-		&self,
-		block_number: <Block::Header as HeaderT>::Number,
-	) -> Result<Option<Block::Hash>, Error> {
-		(self as &SubstrateClient<B, E, Block, RA>).block_hash(block_number)
-	}
-
-	fn header(&self, id: &BlockId<Block>) -> Result<Option<Block::Header>, Error> {
-		(self as &SubstrateClient<B, E, Block, RA>).header(id)
-	}
-
-	fn body(&self, id: &BlockId<Block>) -> Result<Option<Vec<Block::Extrinsic>>, Error> {
-		(self as &SubstrateClient<B, E, Block, RA>).body(id)
-	}
-
-	fn justification(&self, id: &BlockId<Block>) -> Result<Option<Justification>, Error> {
-		(self as &SubstrateClient<B, E, Block, RA>).justification(id)
-	}
-
-	fn header_proof(
-		&self,
-		block_number: <Block::Header as HeaderT>::Number,
-	)-> Result<(Block::Header, StorageProof), Error> {
-		ProofProvider::<Block>::header_proof(self, &BlockId::Number(block_number))
-	}
-
-	fn read_proof(
-		&self,
-		block: &Block::Hash,
-		keys: &mut dyn Iterator<Item=&[u8]>,
-	) -> Result<StorageProof, Error> {
-		ProofProvider::<Block>::read_proof(self, &BlockId::Hash(block.clone()), keys)
-	}
-
-	fn read_child_proof(
-		&self,
-		block: &Block::Hash,
-		storage_key: &[u8],
-		child_info: ChildInfo,
-		keys: &mut dyn Iterator<Item=&[u8]>,
-	) -> Result<StorageProof, Error> {
-		ProofProvider::<Block>::read_child_proof(self, &BlockId::Hash(block.clone()), storage_key, child_info, keys)
-	}
-
-	fn execution_proof(
-		&self,
-		block: &Block::Hash,
-		method: &str,
-		data: &[u8],
-	) -> Result<(Vec<u8>, StorageProof), Error> {
-		ProofProvider::<Block>::execution_proof(
-			self,
-			&BlockId::Hash(block.clone()),
-			method,
-			data,
-		)
-	}
-
-	fn key_changes_proof(
-		&self,
-		first: Block::Hash,
-		last: Block::Hash,
-		min: Block::Hash,
-		max: Block::Hash,
-		storage_key: Option<&StorageKey>,
-		key: &StorageKey,
-	) -> Result<ChangesProof<Block::Header>, Error> {
-		ProofProvider::<Block>::key_changes_proof(self, first, last, min, max, storage_key, key)
-	}
-
-	fn is_descendent_of(&self, base: &Block::Hash, block: &Block::Hash) -> Result<bool, Error> {
-		if base == block {
-			return Ok(false);
-		}
-
-		let ancestor = sp_blockchain::lowest_common_ancestor(self, *block, *base)?;
-
-		Ok(ancestor.hash == *base)
-	}
-}

substrate/client/network/src/config.rs

@@ -43,6 +43,7 @@ use std::{error::Error, fs, io::{self, Write}, net::Ipv4Addr, path::{Path, PathB
 use zeroize::Zeroize;
 use prometheus_endpoint::Registry;
 
+
 /// Network initialization parameters.
 pub struct Params<B: BlockT, H: ExHashT> {
 	/// Assigned roles for our node (full, light, ...).

substrate/client/network/src/protocol.rs

@@ -857,7 +857,7 @@ impl<B: BlockT, H: ExHashT> Protocol<B, H> {
 		let get_justification = request
 			.fields
 			.contains(message::BlockAttributes::JUSTIFICATION);
-		while let Some(header) = self.context_data.chain.header(&id).unwrap_or(None) {
+		while let Some(header) = self.context_data.chain.header(id).unwrap_or(None) {
 			if blocks.len() >= max {
 				break;
 			}
@@ -875,7 +875,7 @@ impl<B: BlockT, H: ExHashT> Protocol<B, H> {
 				body: if get_body {
 					self.context_data
 						.chain
-						.body(&BlockId::Hash(hash))
+						.block_body(&BlockId::Hash(hash))
 						.unwrap_or(None)
 				} else {
 					None
@@ -1300,7 +1300,7 @@ impl<B: BlockT, H: ExHashT> Protocol<B, H> {
 	/// In chain-based consensus, we often need to make sure non-best forks are
 	/// at least temporarily synced.
 	pub fn announce_block(&mut self, hash: B::Hash, data: Vec<u8>) {
-		let header = match self.context_data.chain.header(&BlockId::Hash(hash)) {
+		let header = match self.context_data.chain.header(BlockId::Hash(hash)) {
 			Ok(Some(header)) => header,
 			Ok(None) => {
 				warn!("Trying to announce unknown block: {}", hash);
@@ -1468,7 +1468,7 @@ impl<B: BlockT, H: ExHashT> Protocol<B, H> {
 			request.block
 		);
 		let proof = match self.context_data.chain.execution_proof(
-			&request.block,
+			&BlockId::Hash(request.block),
 			&request.method,
 			&request.data,
 		) {
@@ -1601,7 +1601,7 @@ impl<B: BlockT, H: ExHashT> Protocol<B, H> {
 		trace!(target: "sync", "Remote read request {} from {} ({} at {})",
 			request.id, who, keys_str(), request.block);
 		let proof = match self.context_data.chain.read_proof(
-			&request.block,
+			&BlockId::Hash(request.block),
 			&mut request.keys.iter().map(AsRef::as_ref)
 		) {
 			Ok(proof) => proof,
@@ -1650,7 +1650,7 @@ impl<B: BlockT, H: ExHashT> Protocol<B, H> {
 			request.id, who, request.storage_key.to_hex::<String>(), keys_str(), request.block);
 		let proof = if let Some(child_info) = ChildInfo::resolve_child_info(request.child_type, &request.child_info[..]) {
 			match self.context_data.chain.read_child_proof(
-				&request.block,
+				&BlockId::Hash(request.block),
 				&request.storage_key,
 				child_info,
 				&mut request.keys.iter().map(AsRef::as_ref),
@@ -1708,7 +1708,7 @@ impl<B: BlockT, H: ExHashT> Protocol<B, H> {
 	) {
 		trace!(target: "sync", "Remote header proof request {} from {} ({})",
 			request.id, who, request.block);
-		let (header, proof) = match self.context_data.chain.header_proof(request.block) {
+		let (header, proof) = match self.context_data.chain.header_proof(&BlockId::Number(request.block)) {
 			Ok((header, proof)) => (Some(header), proof),
 			Err(error) => {
 				trace!(target: "sync", "Remote header proof request {} from {} ({}) failed with: {}",

substrate/client/network/src/protocol/block_requests.rs

@@ -192,7 +192,7 @@ where
 
 		let mut blocks = Vec::new();
 		let mut block_id = from_block_id;
-		while let Some(header) = self.chain.header(&block_id).unwrap_or(None) {
+		while let Some(header) = self.chain.header(block_id).unwrap_or(None) {
 			if blocks.len() >= max_blocks as usize {
 				break
 			}
@@ -209,7 +209,7 @@ where
 					Vec::new()
 				},
 				body: if get_body {
-					self.chain.body(&BlockId::Hash(hash))?
+					self.chain.block_body(&BlockId::Hash(hash))?
 						.unwrap_or(Vec::new())
 						.iter_mut()
 						.map(|extrinsic| extrinsic.encode())

substrate/client/network/src/protocol/light_client_handler.rs

@@ -57,7 +57,10 @@ use sc_client_api::StorageProof;
 use sc_peerset::ReputationChange;
 use sp_core::storage::{ChildInfo, StorageKey};
 use sp_blockchain::{Error as ClientError};
-use sp_runtime::traits::{Block, Header, NumberFor, Zero};
+use sp_runtime::{
+	traits::{Block, Header, NumberFor, Zero},
+	generic::BlockId,
+};
 use std::{
 	collections::{BTreeMap, VecDeque, HashMap},
 	iter,
@@ -429,7 +432,7 @@ where
 
 		let block = Decode::decode(&mut request.block.as_ref())?;
 
-		let proof = match self.chain.execution_proof(&block, &request.method, &request.data) {
+		let proof = match self.chain.execution_proof(&BlockId::Hash(block), &request.method, &request.data) {
 			Ok((_, proof)) => proof,
 			Err(e) => {
 				log::trace!("remote call request from {} ({} at {:?}) failed with: {}",
@@ -468,7 +471,7 @@ where
 
 		let block = Decode::decode(&mut request.block.as_ref())?;
 
-		let proof = match self.chain.read_proof(&block, &mut request.keys.iter().map(AsRef::as_ref)) {
+		let proof = match self.chain.read_proof(&BlockId::Hash(block), &mut request.keys.iter().map(AsRef::as_ref)) {
 			Ok(proof) => proof,
 			Err(error) => {
 				log::trace!("remote read request from {} ({} at {:?}) failed with: {}",
@@ -510,7 +513,7 @@ where
 		let proof =
 			if let Some(info) = ChildInfo::resolve_child_info(request.child_type, &request.child_info[..]) {
 				match self.chain.read_child_proof(
-					&block,
+					&BlockId::Hash(block),
 					&request.storage_key,
 					info,
 					&mut request.keys.iter().map(AsRef::as_ref)
@@ -554,8 +557,7 @@ where
 		log::trace!("remote header proof request from {} ({:?})", peer, request.block);
 
 		let block = Decode::decode(&mut request.block.as_ref())?;
-
-		let (header, proof) = match self.chain.header_proof(block) {
+		let (header, proof) = match self.chain.header_proof(&BlockId::Number(block)) {
 			Ok((header, proof)) => (header.encode(), proof),
 			Err(error) => {
 				log::trace!("remote header proof request from {} ({:?}) failed with: {}",

substrate/client/network/src/protocol/sync.rs

@@ -28,7 +28,7 @@
 //!
 
 use blocks::BlockCollection;
-use sp_blockchain::{Error as ClientError, Info as BlockchainInfo};
+use sp_blockchain::{Error as ClientError, Info as BlockchainInfo, HeaderMetadata};
 use sp_consensus::{BlockOrigin, BlockStatus,
 	block_validation::{BlockAnnounceValidator, Validation},
 	import_queue::{IncomingBlock, BlockImportResult, BlockImportError}
@@ -459,7 +459,7 @@ impl<B: BlockT> ChainSync<B> {
 	pub fn request_justification(&mut self, hash: &B::Hash, number: NumberFor<B>) {
 		let client = &self.client;
 		self.extra_justifications.schedule((*hash, number), |base, block| {
-			client.is_descendent_of(base, block)
+			is_descendent_of(&**client, base, block)
 		})
 	}
 
@@ -467,7 +467,7 @@ impl<B: BlockT> ChainSync<B> {
 	pub fn request_finality_proof(&mut self, hash: &B::Hash, number: NumberFor<B>) {
 		let client = &self.client;
 		self.extra_finality_proofs.schedule((*hash, number), |base, block| {
-			client.is_descendent_of(base, block)
+			is_descendent_of(&**client, base, block)
 		})
 	}
 
@@ -693,7 +693,7 @@ impl<B: BlockT> ChainSync<B> {
 							}).collect()
 						}
 						PeerSyncState::AncestorSearch(num, state) => {
-							let matching_hash = match (blocks.get(0), self.client.block_hash(*num)) {
+							let matching_hash = match (blocks.get(0), self.client.hash(*num)) {
 								(Some(block), Ok(maybe_our_block_hash)) => {
 									trace!(target: "sync", "Got ancestry block #{} ({}) from peer {}", num, block.hash, who);
 									maybe_our_block_hash.filter(|x| x == &block.hash)
@@ -1001,7 +1001,7 @@ impl<B: BlockT> ChainSync<B> {
 	pub fn on_block_finalized(&mut self, hash: &B::Hash, number: NumberFor<B>) {
 		let client = &self.client;
 		let r = self.extra_finality_proofs.on_block_finalized(hash, number, |base, block| {
-			client.is_descendent_of(base, block)
+			is_descendent_of(&**client, base, block)
 		});
 
 		if let Err(err) = r {
@@ -1010,7 +1010,7 @@ impl<B: BlockT> ChainSync<B> {
 
 		let client = &self.client;
 		let r = self.extra_justifications.on_block_finalized(hash, number, |base, block| {
-			client.is_descendent_of(base, block)
+			is_descendent_of(&**client, base, block)
 		});
 
 		if let Err(err) = r {
@@ -1383,6 +1383,21 @@ fn fork_sync_request<B: BlockT>(
 	None
 }
 
+/// Returns `true` if the given `block` is a descendent of `base`.
+fn is_descendent_of<Block, T>(client: &T, base: &Block::Hash, block: &Block::Hash) -> sp_blockchain::Result<bool>
+	where
+		Block: BlockT,
+		T: HeaderMetadata<Block, Error = sp_blockchain::Error> + ?Sized,
+{
+	if base == block {
+		return Ok(false);
+	}
+
+	let ancestor = sp_blockchain::lowest_common_ancestor(client, *block, *base)?;
+
+	Ok(ancestor.hash == *base)
+}
+
 #[cfg(test)]
 mod test {
 	use super::*;

substrate/client/network/src/service.rs

@@ -50,6 +50,7 @@ use crate::protocol::{self, Protocol, PeerInfo};
 use crate::protocol::{event::Event, light_dispatch::{AlwaysBadChecker, RequestData}};
 use crate::protocol::sync::SyncState;
 
+
 /// Minimum Requirements for a Hash within Networking
 pub trait ExHashT: std::hash::Hash + Eq + std::fmt::Debug + Clone + Send + Sync + 'static {}
 

substrate/client/network/test/src/lib.rs

@@ -29,12 +29,7 @@ use sc_network::config::FinalityProofProvider;
 use sp_blockchain::{
 	Result as ClientResult, well_known_cache_keys::{self, Id as CacheKeyId}, Info as BlockchainInfo,
 };
-use sc_client_api::{
-	BlockchainEvents, BlockImportNotification,
-	FinalityNotifications, ImportNotifications,
-	FinalityNotification,
-	backend::{TransactionFor, AuxStore, Backend, Finalizer},
-};
+use sc_client_api::{BlockchainEvents, BlockImportNotification, FinalityNotifications, ImportNotifications, FinalityNotification, backend::{TransactionFor, AuxStore, Backend, Finalizer}, BlockBackend};
 use sc_block_builder::{BlockBuilder, BlockBuilderProvider};
 use sc_client::LongestChain;
 use sc_network::config::Roles;

substrate/client/rpc/src/chain/chain_full.rs

@@ -20,7 +20,7 @@ use std::sync::Arc;
 use rpc::futures::future::result;
 
 use sc_rpc_api::Subscriptions;
-use sc_client_api::{BlockchainEvents, BlockBody};
+use sc_client_api::{BlockchainEvents, BlockBackend};
 use sp_runtime::{generic::{BlockId, SignedBlock}, traits::{Block as BlockT}};
 
 use super::{ChainBackend, client_err, error::FutureResult};
@@ -50,7 +50,7 @@ impl<Block: BlockT, Client> FullChain<Block, Client> {
 
 impl<Block, Client> ChainBackend<Client, Block> for FullChain<Block, Client> where
 	Block: BlockT + 'static,
-	Client: BlockBody<Block> + HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
+	Client: BlockBackend<Block> + HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
 {
 	fn client(&self) -> &Arc<Client> {
 		&self.client

substrate/client/rpc/src/chain/mod.rs

@@ -46,7 +46,7 @@ use self::error::{Result, Error, FutureResult};
 
 pub use sc_rpc_api::chain::*;
 use sp_blockchain::HeaderBackend;
-use sc_client_api::BlockBody;
+use sc_client_api::BlockBackend;
 
 /// Blockchain backend API
 trait ChainBackend<Client, Block: BlockT>: Send + Sync + 'static
@@ -182,7 +182,7 @@ pub fn new_full<Block: BlockT, Client>(
 ) -> Chain<Block, Client>
 	where
 		Block: BlockT + 'static,
-		Client: BlockBody<Block> + HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
+		Client: BlockBackend<Block> + HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
 {
 	Chain {
 		backend: Box::new(self::chain_full::FullChain::new(client, subscriptions)),
@@ -198,7 +198,7 @@ pub fn new_light<Block: BlockT, Client, F: Fetcher<Block>>(
 ) -> Chain<Block, Client>
 	where
 		Block: BlockT + 'static,
-		Client: BlockBody<Block> + HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
+		Client: BlockBackend<Block> + HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
 		F: Send + Sync + 'static,
 {
 	Chain {

substrate/client/service/src/chain_ops.rs

@@ -35,7 +35,7 @@ use sp_consensus::{
 use sc_executor::{NativeExecutor, NativeExecutionDispatch};
 
 use std::{io::{Read, Write, Seek}, pin::Pin};
-use sc_client_api::BlockBody;
+use sc_client_api::BlockBackend;
 
 /// Build a chain spec json
 pub fn build_spec(spec: &dyn ChainSpec, raw: bool) -> error::Result<String> {

substrate/client/src/client.rs

@@ -71,7 +71,7 @@ pub use sc_client_api::{
 	},
 	client::{
 		ImportNotifications, FinalityNotification, FinalityNotifications, BlockImportNotification,
-		ClientInfo, BlockchainEvents, BlockBody, ProvideUncles, BadBlocks, ForkBlocks,
+		ClientInfo, BlockchainEvents, BlockBackend, ProvideUncles, BadBlocks, ForkBlocks,
 		BlockOf,
 	},
 	execution_extensions::{ExecutionExtensions, ExecutionStrategies},
@@ -1058,11 +1058,6 @@ impl<B, E, Block, RA> Client<B, E, Block, RA> where
 		self.backend.blockchain().body(*id)
 	}
 
-	/// Get block justification set by id.
-	pub fn justification(&self, id: &BlockId<Block>) -> sp_blockchain::Result<Option<Justification>> {
-		self.backend.blockchain().justification(*id)
-	}
-
 	/// Gets the uncles of the block with `target_hash` going back `max_generation` ancestors.
 	pub fn uncles(&self, target_hash: Block::Hash, max_generation: NumberFor<Block>) -> sp_blockchain::Result<Vec<Block::Hash>> {
 		let load_header = |id: Block::Hash| -> sp_blockchain::Result<Block::Header> {
@@ -1865,7 +1860,7 @@ where
 	}
 }
 
-impl<B, E, Block, RA> BlockBody<Block> for Client<B, E, Block, RA>
+impl<B, E, Block, RA> BlockBackend<Block> for Client<B, E, Block, RA>
 	where
 		B: backend::Backend<Block>,
 		E: CallExecutor<Block>,
@@ -1886,6 +1881,33 @@ impl<B, E, Block, RA> BlockBody<Block> for Client<B, E, Block, RA>
 			_ => None,
 		})
 	}
+
+	fn block_status(&self, id: &BlockId<Block>) -> sp_blockchain::Result<BlockStatus> {
+		// this can probably be implemented more efficiently
+		if let BlockId::Hash(ref h) = id {
+			if self.importing_block.read().as_ref().map_or(false, |importing| h == importing) {
+				return Ok(BlockStatus::Queued);
+			}
+		}
+		let hash_and_number = match id.clone() {
+			BlockId::Hash(hash) => self.backend.blockchain().number(hash)?.map(|n| (hash, n)),
+			BlockId::Number(n) => self.backend.blockchain().hash(n)?.map(|hash| (hash, n)),
+		};
+		match hash_and_number {
+			Some((hash, number)) => {
+				if self.backend.have_state_at(&hash, number) {
+					Ok(BlockStatus::InChainWithState)
+				} else {
+					Ok(BlockStatus::InChainPruned)
+				}
+			}
+			None => Ok(BlockStatus::Unknown),
+		}
+	}
+
+	fn justification(&self, id: &BlockId<Block>) -> sp_blockchain::Result<Option<Justification>> {
+		self.backend.blockchain().justification(*id)
+	}
 }
 
 impl<B, E, Block, RA> backend::AuxStore for Client<B, E, Block, RA>

substrate/client/src/lib.rs

@@ -98,7 +98,7 @@ pub use crate::{
 	client::{
 		new_with_backend,
 		new_in_mem,
-		BlockBody, ImportNotifications, FinalityNotifications, BlockchainEvents, LockImportRun,
+		BlockBackend, ImportNotifications, FinalityNotifications, BlockchainEvents, LockImportRun,
 		BlockImportNotification, Client, ClientInfo, ExecutionStrategies, FinalityNotification,
 		LongestChain, BlockOf, ProvideUncles, BadBlocks, ForkBlocks, apply_aux,
 	},

substrate/client/transaction-pool/src/api.rs

@@ -25,7 +25,7 @@ use futures::{
 use sc_client_api::{
 	blockchain::HeaderBackend,
 	light::{Fetcher, RemoteCallRequest, RemoteBodyRequest},
-	BlockBody,
+	BlockBackend,
 };
 use sp_runtime::{
 	generic::BlockId, traits::{self, Block as BlockT, BlockIdTo, Header as HeaderT, Hash as HashT},
@@ -63,7 +63,7 @@ impl<Client, Block> FullChainApi<Client, Block> where
 
 impl<Client, Block> sc_transaction_graph::ChainApi for FullChainApi<Client, Block> where
 	Block: BlockT,
-	Client: ProvideRuntimeApi<Block> + BlockBody<Block> + BlockIdTo<Block>,
+	Client: ProvideRuntimeApi<Block> + BlockBackend<Block> + BlockIdTo<Block>,
 	Client: Send + Sync + 'static,
 	Client::Api: TaggedTransactionQueue<Block>,
 	sp_api::ApiErrorFor<Client, Block>: Send,

substrate/primitives/blockchain/src/header_metadata.rs

@@ -30,7 +30,7 @@ const LRU_CACHE_SIZE: usize = 5_000;
 /// small branches, and because of our current query pattern:
 /// lca(best, final), lca(best + 1, final), lca(best + 2, final), etc.
 /// The first call is O(h) but the others are O(1).
-pub fn lowest_common_ancestor<Block: BlockT, T: HeaderMetadata<Block>>(
+pub fn lowest_common_ancestor<Block: BlockT, T: HeaderMetadata<Block> + ?Sized>(
 	backend: &T,
 	id_one: Block::Hash,
 	id_two: Block::Hash,