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/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::*;