Move sc-client into sc-service (#5502)

* Drop client from sc-network and sc-client-db, move LongestChain to sc-client-api

* move leaves, cht, in_mem to sc-client-api, drop client from sc-finality-grandpa

* drop sc-service from sc-rpc

* drop sc-service from sc-consensus-aura

* drop sc-client from manual-seal and babe

* drop sc-client from utils/frame/rpc/system and utils/frame/benchmarking-cli

* drop sc-client from bin/node and bin/node-template

* drop sc-client

* fix tests

* remove check -p sc-client from gitlab.yml

* fix warnings

* fixes ui test

* fix light client tests

* adds associated Client type to AbstractService

* adds UsageProvider to Client

* fixed ui test, again

* tried and failed to get node-cli to compile for wasm

* thanks to tomaka for helping me get node-cli to compile for wasmm

* ui test pls pas 🙏🏾

* all tests passing 🪄

* no_run documentation code

* rm -f documentation code

* ClientProvider

* fix mega trait

* move LongestChain to sc-consensus, use adds minimal bounds to AbstractService::Client

* adds license to sc-consensus

Co-authored-by: Benjamin Kampmann <ben@parity.io>

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

@@ -54,8 +54,13 @@ use libp2p::{
 };
 use nohash_hasher::IntMap;
 use prost::Message;
-use sc_client::light::fetcher;
-use sc_client_api::StorageProof;
+use sc_client_api::{
+	StorageProof,
+	light::{
+		self, RemoteReadRequest, RemoteBodyRequest, ChangesProof,
+		RemoteCallRequest, RemoteChangesRequest, RemoteHeaderRequest,
+	}
+};
 use sc_peerset::ReputationChange;
 use sp_core::{
 	storage::{ChildInfo, ChildType,StorageKey, PrefixedStorageKey},
@@ -193,27 +198,27 @@ pub enum Error {
 #[derive(Debug)]
 pub enum Request<B: Block> {
 	Body {
-		request: fetcher::RemoteBodyRequest<B::Header>,
+		request: RemoteBodyRequest<B::Header>,
 		sender: oneshot::Sender<Result<Vec<B::Extrinsic>, ClientError>>
 	},
 	Header {
-		request: fetcher::RemoteHeaderRequest<B::Header>,
+		request: light::RemoteHeaderRequest<B::Header>,
 		sender: oneshot::Sender<Result<B::Header, ClientError>>
 	},
 	Read {
-		request: fetcher::RemoteReadRequest<B::Header>,
+		request: light::RemoteReadRequest<B::Header>,
 		sender: oneshot::Sender<Result<HashMap<Vec<u8>, Option<Vec<u8>>>, ClientError>>
 	},
 	ReadChild {
-		request: fetcher::RemoteReadChildRequest<B::Header>,
+		request: light::RemoteReadChildRequest<B::Header>,
 		sender: oneshot::Sender<Result<HashMap<Vec<u8>, Option<Vec<u8>>>, ClientError>>
 	},
 	Call {
-		request: fetcher::RemoteCallRequest<B::Header>,
+		request: light::RemoteCallRequest<B::Header>,
 		sender: oneshot::Sender<Result<Vec<u8>, ClientError>>
 	},
 	Changes {
-		request: fetcher::RemoteChangesRequest<B::Header>,
+		request: light::RemoteChangesRequest<B::Header>,
 		sender: oneshot::Sender<Result<Vec<(NumberFor<B>, u32)>, ClientError>>
 	}
 }
@@ -283,7 +288,7 @@ pub struct LightClientHandler<B: Block> {
 	/// Blockchain client.
 	chain: Arc<dyn Client<B>>,
 	/// Verifies that received responses are correct.
-	checker: Arc<dyn fetcher::FetchChecker<B>>,
+	checker: Arc<dyn light::FetchChecker<B>>,
 	/// Peer information (addresses, their best block, etc.)
 	peers: HashMap<PeerId, PeerInfo<B>>,
 	/// Futures sending back response to remote clients.
@@ -306,7 +311,7 @@ where
 	pub fn new(
 		cfg: Config,
 		chain: Arc<dyn Client<B>>,
-		checker: Arc<dyn fetcher::FetchChecker<B>>,
+		checker: Arc<dyn light::FetchChecker<B>>,
 		peerset: sc_peerset::PeersetHandle,
 	) -> Self {
 		LightClientHandler {
@@ -471,7 +476,7 @@ where
 						}
 						r
 					};
-					let reply = self.checker.check_changes_proof(&request, fetcher::ChangesProof {
+					let reply = self.checker.check_changes_proof(&request, light::ChangesProof {
 						max_block,
 						proof: response.proof,
 						roots,
@@ -712,7 +717,7 @@ where
 					request.last,
 					error);
 
-				fetcher::ChangesProof::<B::Header> {
+				light::ChangesProof::<B::Header> {
 					max_block: Zero::zero(),
 					proof: Vec::new(),
 					roots: BTreeMap::new(),
@@ -1289,6 +1294,7 @@ fn fmt_keys(first: Option<&Vec<u8>>, last: Option<&Vec<u8>>) -> String {
 
 #[cfg(test)]
 mod tests {
+	use super::*;
 	use async_std::task;
 	use assert_matches::assert_matches;
 	use codec::Encode;
@@ -1313,8 +1319,7 @@ mod tests {
 		swarm::{NetworkBehaviour, NetworkBehaviourAction, PollParameters},
 		yamux
 	};
-	use sc_client_api::StorageProof;
-	use sc_client::light::fetcher;
+	use sc_client_api::{StorageProof, RemoteReadChildRequest, FetchChecker};
 	use sp_blockchain::{Error as ClientError};
 	use sp_core::storage::ChildInfo;
 	use std::{
@@ -1358,12 +1363,12 @@ mod tests {
 		_mark: std::marker::PhantomData<B>
 	}
 
-	impl<B: BlockT> fetcher::FetchChecker<B> for DummyFetchChecker<B> {
+	impl<B: BlockT> light::FetchChecker<B> for DummyFetchChecker<B> {
 		fn check_header_proof(
 			&self,
-			_request: &fetcher::RemoteHeaderRequest<B::Header>,
+			_request: &RemoteHeaderRequest<B::Header>,
 			header: Option<B::Header>,
-			_remote_proof: fetcher::StorageProof,
+			_remote_proof: StorageProof,
 		) -> Result<B::Header, ClientError> {
 			match self.ok {
 				true if header.is_some() => Ok(header.unwrap()),
@@ -1373,8 +1378,8 @@ mod tests {
 
 		fn check_read_proof(
 			&self,
-			request: &fetcher::RemoteReadRequest<B::Header>,
-			_: fetcher::StorageProof,
+			request: &RemoteReadRequest<B::Header>,
+			_: StorageProof,
 		) -> Result<HashMap<Vec<u8>, Option<Vec<u8>>>, ClientError> {
 			match self.ok {
 				true => Ok(request.keys
@@ -1389,8 +1394,8 @@ mod tests {
 
 		fn check_read_child_proof(
 			&self,
-			request: &fetcher::RemoteReadChildRequest<B::Header>,
-			_: fetcher::StorageProof,
+			request: &RemoteReadChildRequest<B::Header>,
+			_: StorageProof,
 		) -> Result<HashMap<Vec<u8>, Option<Vec<u8>>>, ClientError> {
 			match self.ok {
 				true => Ok(request.keys
@@ -1405,8 +1410,8 @@ mod tests {
 
 		fn check_execution_proof(
 			&self,
-			_: &fetcher::RemoteCallRequest<B::Header>,
-			_: fetcher::StorageProof,
+			_: &RemoteCallRequest<B::Header>,
+			_: StorageProof,
 		) -> Result<Vec<u8>, ClientError> {
 			match self.ok {
 				true => Ok(vec![42]),
@@ -1416,8 +1421,8 @@ mod tests {
 
 		fn check_changes_proof(
 			&self,
-			_: &fetcher::RemoteChangesRequest<B::Header>,
-			_: fetcher::ChangesProof<B::Header>
+			_: &RemoteChangesRequest<B::Header>,
+			_: ChangesProof<B::Header>
 		) -> Result<Vec<(NumberFor<B>, u32)>, ClientError> {
 			match self.ok {
 				true => Ok(vec![(100.into(), 2)]),
@@ -1427,7 +1432,7 @@ mod tests {
 
 		fn check_body_proof(
 			&self,
-			_: &fetcher::RemoteBodyRequest<B::Header>,
+			_: &RemoteBodyRequest<B::Header>,
 			body: Vec<B::Extrinsic>
 		) -> Result<Vec<B::Extrinsic>, ClientError> {
 			match self.ok {
@@ -1545,7 +1550,7 @@ mod tests {
 
 		// Issue our first request!
 		let chan = oneshot::channel();
-		let request = fetcher::RemoteCallRequest {
+		let request = light::RemoteCallRequest {
 			block: Default::default(),
 			header: dummy_header(),
 			method: "test".into(),
@@ -1602,7 +1607,7 @@ mod tests {
 		assert_eq!(1, behaviour.peers.len());
 
 		let chan = oneshot::channel();
-		let request = fetcher::RemoteCallRequest {
+		let request = light::RemoteCallRequest {
 			block: Default::default(),
 			header: dummy_header(),
 			method: "test".into(),
@@ -1677,7 +1682,7 @@ mod tests {
 		assert_eq!(1, behaviour.peers.len());
 
 		let chan = oneshot::channel();
-		let request = fetcher::RemoteCallRequest {
+		let request = light::RemoteCallRequest {
 			block: Default::default(),
 			header: dummy_header(),
 			method: "test".into(),
@@ -1736,7 +1741,7 @@ mod tests {
 		assert_eq!(4, behaviour.peers.len());
 
 		let mut chan = oneshot::channel();
-		let request = fetcher::RemoteCallRequest {
+		let request = light::RemoteCallRequest {
 			block: Default::default(),
 			header: dummy_header(),
 			method: "test".into(),
@@ -1852,7 +1857,7 @@ mod tests {
 	#[test]
 	fn receives_remote_call_response() {
 		let mut chan = oneshot::channel();
-		let request = fetcher::RemoteCallRequest {
+		let request = light::RemoteCallRequest {
 			block: Default::default(),
 			header: dummy_header(),
 			method: "test".into(),
@@ -1866,7 +1871,7 @@ mod tests {
 	#[test]
 	fn receives_remote_read_response() {
 		let mut chan = oneshot::channel();
-		let request = fetcher::RemoteReadRequest {
+		let request = light::RemoteReadRequest {
 			header: dummy_header(),
 			block: Default::default(),
 			keys: vec![b":key".to_vec()],
@@ -1880,7 +1885,7 @@ mod tests {
 	fn receives_remote_read_child_response() {
 		let mut chan = oneshot::channel();
 		let child_info = ChildInfo::new_default(&b":child_storage:default:sub"[..]);
-		let request = fetcher::RemoteReadChildRequest {
+		let request = light::RemoteReadChildRequest {
 			header: dummy_header(),
 			block: Default::default(),
 			storage_key: child_info.prefixed_storage_key(),
@@ -1894,7 +1899,7 @@ mod tests {
 	#[test]
 	fn receives_remote_header_response() {
 		let mut chan = oneshot::channel();
-		let request = fetcher::RemoteHeaderRequest {
+		let request = light::RemoteHeaderRequest {
 			cht_root: Default::default(),
 			block: 1,
 			retry_count: None,
@@ -1906,7 +1911,7 @@ mod tests {
 	#[test]
 	fn receives_remote_changes_response() {
 		let mut chan = oneshot::channel();
-		let request = fetcher::RemoteChangesRequest {
+		let request = light::RemoteChangesRequest {
 			changes_trie_configs: vec![sp_core::ChangesTrieConfigurationRange {
 				zero: (0, Default::default()),
 				end: None,
@@ -1951,7 +1956,7 @@ mod tests {
 	#[test]
 	fn send_receive_call() {
 		let chan = oneshot::channel();
-		let request = fetcher::RemoteCallRequest {
+		let request = light::RemoteCallRequest {
 			block: Default::default(),
 			header: dummy_header(),
 			method: "test".into(),
@@ -1966,7 +1971,7 @@ mod tests {
 	#[test]
 	fn send_receive_read() {
 		let chan = oneshot::channel();
-		let request = fetcher::RemoteReadRequest {
+		let request = light::RemoteReadRequest {
 			header: dummy_header(),
 			block: Default::default(),
 			keys: vec![b":key".to_vec()],
@@ -1981,7 +1986,7 @@ mod tests {
 	fn send_receive_read_child() {
 		let chan = oneshot::channel();
 		let child_info = ChildInfo::new_default(&b":child_storage:default:sub"[..]);
-		let request = fetcher::RemoteReadChildRequest {
+		let request = light::RemoteReadChildRequest {
 			header: dummy_header(),
 			block: Default::default(),
 			storage_key: child_info.prefixed_storage_key(),
@@ -1997,7 +2002,7 @@ mod tests {
 	fn send_receive_header() {
 		let _ = env_logger::try_init();
 		let chan = oneshot::channel();
-		let request = fetcher::RemoteHeaderRequest {
+		let request = light::RemoteHeaderRequest {
 			cht_root: Default::default(),
 			block: 1,
 			retry_count: None,
@@ -2010,7 +2015,7 @@ mod tests {
 	#[test]
 	fn send_receive_changes() {
 		let chan = oneshot::channel();
-		let request = fetcher::RemoteChangesRequest {
+		let request = light::RemoteChangesRequest {
 			changes_trie_configs: vec![sp_core::ChangesTrieConfigurationRange {
 				zero: (0, Default::default()),
 				end: None,