Recover transaction pool on light client (#3833)

* recover tx pool on light client

* revert local tests fix

* removed import renamings

* futures03::Future -> std::future::Future

* Update core/transaction-pool/graph/src/error.rs

Co-Authored-By: Tomasz Drwięga <tomusdrw@users.noreply.github.com>

* replace remove_from_ready with remove_invalid

* avoid excess hashing

* debug -> warn

* TransactionPool + BasicTransactionPool

* pause future tx reject when resubmitting

* bump impl_version to make CI happy

* and revert back local test fixes

* alter doc to restart CI

* Transaction::clone() -> Transaction::duplicate()

* transactions -> updated_tranasctions

* remove explicit consensus-common ref

* ::std:: -> std::

* manual set/unset flag -> calling clusore with given flag value

* removed comments

* removed force argument

* BestIterator -> Box<Iterator>

* separate crate for TxPool + Maintainer trait

* long line fix

* pos-merge fix

* fix benches compilation

* Rename txpoolapi to txpool_api

* Clean up.

* Finalize merge.

* post-merge fix

* Move transaction pool api to primitives directly.

* Consistent naming for txpool-runtime-api

* Warn about missing docs.

* Move  abstraction for offchain calls to tx-pool-api.

* Merge RPC instantiation.

* Update cargo.lock

* Post merge fixes.

* Avoid depending on client.

* Fix build

substrate/test/utils/runtime/client/src/lib.rs

@@ -30,7 +30,15 @@ pub use runtime;
 
 use primitives::sr25519;
 use runtime::genesismap::{GenesisConfig, additional_storage_with_genesis};
-use sr_primitives::traits::{Block as BlockT, Header as HeaderT, Hash as HashT};
+use sr_primitives::traits::{Block as BlockT, Header as HeaderT, Hash as HashT, NumberFor};
+use client::{
+	light::fetcher::{
+		Fetcher,
+		RemoteHeaderRequest, RemoteReadRequest, RemoteReadChildRequest,
+		RemoteCallRequest, RemoteChangesRequest, RemoteBodyRequest,
+	},
+};
+
 
 /// A prelude to import in tests.
 pub mod prelude {
@@ -247,6 +255,81 @@ impl<B> TestClientBuilderExt<B> for TestClientBuilder<
 	}
 }
 
+/// Type of optional fetch callback.
+type MaybeFetcherCallback<Req, Resp> = Option<Box<dyn Fn(Req) -> Result<Resp, sp_blockchain::Error> + Send + Sync>>;
+
+/// Type of fetcher future result.
+type FetcherFutureResult<Resp> = futures::future::Ready<Result<Resp, sp_blockchain::Error>>;
+
+/// Implementation of light client fetcher used in tests.
+#[derive(Default)]
+pub struct LightFetcher {
+	call: MaybeFetcherCallback<RemoteCallRequest<runtime::Header>, Vec<u8>>,
+	body: MaybeFetcherCallback<RemoteBodyRequest<runtime::Header>, Vec<runtime::Extrinsic>>,
+}
+
+impl LightFetcher {
+	/// Sets remote call callback.
+	pub fn with_remote_call(
+		self,
+		call: MaybeFetcherCallback<RemoteCallRequest<runtime::Header>, Vec<u8>>,
+	) -> Self {
+		LightFetcher {
+			call,
+			body: self.body,
+		}
+	}
+
+	/// Sets remote body callback.
+	pub fn with_remote_body(
+		self,
+		body: MaybeFetcherCallback<RemoteBodyRequest<runtime::Header>, Vec<runtime::Extrinsic>>,
+	) -> Self {
+		LightFetcher {
+			call: self.call,
+			body,
+		}
+	}
+}
+
+impl Fetcher<runtime::Block> for LightFetcher {
+	type RemoteHeaderResult = FetcherFutureResult<runtime::Header>;
+	type RemoteReadResult = FetcherFutureResult<HashMap<Vec<u8>, Option<Vec<u8>>>>;
+	type RemoteCallResult = FetcherFutureResult<Vec<u8>>;
+	type RemoteChangesResult = FetcherFutureResult<Vec<(NumberFor<runtime::Block>, u32)>>;
+	type RemoteBodyResult = FetcherFutureResult<Vec<runtime::Extrinsic>>;
+
+	fn remote_header(&self, _: RemoteHeaderRequest<runtime::Header>) -> Self::RemoteHeaderResult {
+		unimplemented!()
+	}
+
+	fn remote_read(&self, _: RemoteReadRequest<runtime::Header>) -> Self::RemoteReadResult {
+		unimplemented!()
+	}
+
+	fn remote_read_child(&self, _: RemoteReadChildRequest<runtime::Header>) -> Self::RemoteReadResult {
+		unimplemented!()
+	}
+
+	fn remote_call(&self, req: RemoteCallRequest<runtime::Header>) -> Self::RemoteCallResult {
+		match self.call {
+			Some(ref call) => futures::future::ready(call(req)),
+			None => unimplemented!(),
+		}
+	}
+
+	fn remote_changes(&self, _: RemoteChangesRequest<runtime::Header>) -> Self::RemoteChangesResult {
+		unimplemented!()
+	}
+
+	fn remote_body(&self, req: RemoteBodyRequest<runtime::Header>) -> Self::RemoteBodyResult {
+		match self.body {
+			Some(ref body) => futures::future::ready(body(req)),
+			None => unimplemented!(),
+		}
+	}
+}
+
 /// Creates new client instance used for tests.
 pub fn new() -> Client<Backend> {
 	TestClientBuilder::new().build()
@@ -275,3 +358,8 @@ pub fn new_light() -> (
 		backend,
 	)
 }
+
+/// Creates new light client fetcher used for tests.
+pub fn new_light_fetcher() -> LightFetcher {
+	LightFetcher::default()
+}