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

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.

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;
 

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.

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,

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)
-	}
-}

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, ...).

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: {}",

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())