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
2026-04-26 20:27:58 +00:00 · 2019-11-28 03:00:54 +03:00
parent 3e26fceda4
commit a782021ee8
64 changed files with 2370 additions and 667 deletions
@@ -18,20 +18,34 @@

 use std::sync::Arc;

-use codec::{self, Codec, Encode};
-use sp_blockchain::HeaderBackend;
-use jsonrpc_core::{Result, Error, ErrorCode};
+use codec::{self, Codec, Decode, Encode};
+use client::{
+	light::blockchain::{future_header, RemoteBlockchain},
+	light::fetcher::{Fetcher, RemoteCallRequest},
+};
+use jsonrpc_core::{
+	Error, ErrorCode,
+	futures::future::{result, Future},
+};
 use jsonrpc_derive::rpc;
+use futures::future::{ready, TryFutureExt};
+use sp_blockchain::{
+	HeaderBackend,
+	Error as ClientError
+};
 use sr_primitives::{
 	generic::BlockId,
 	traits,
 };
 use substrate_primitives::hexdisplay::HexDisplay;
-use sc_transaction_graph::{self, ChainApi, Pool};
+use txpool_api::{TransactionPool, InPoolTransaction};

 pub use frame_system_rpc_runtime_api::AccountNonceApi;
 pub use self::gen_client::Client as SystemClient;

+/// Future that resolves to account nonce.
+pub type FutureResult<T> = Box<dyn Future<Item = T, Error = Error> + Send>;
+
 /// System RPC methods.
 #[rpc]
 pub trait SystemApi<AccountId, Index> {
@@ -41,22 +55,22 @@ pub trait SystemApi<AccountId, Index> {
 	/// currently in the pool and if no transactions are found in the pool
 	/// it fallbacks to query the index from the runtime (aka. state nonce).
 	#[rpc(name = "system_accountNextIndex", alias("account_nextIndex"))]
-	fn nonce(&self, account: AccountId) -> Result<Index>;
+	fn nonce(&self, account: AccountId) -> FutureResult<Index>;
 }

 const RUNTIME_ERROR: i64 = 1;

-/// An implementation of System-specific RPC methods.
-pub struct System<P: ChainApi, C, B> {
+/// An implementation of System-specific RPC methods on full client.
+pub struct FullSystem<P: TransactionPool, C, B> {
 	client: Arc<C>,
-	pool: Arc<Pool<P>>,
+	pool: Arc<P>,
 	_marker: std::marker::PhantomData<B>,
 }

-impl<P: ChainApi, C, B> System<P, C, B> {
-	/// Create new `System` given client and transaction pool.
-	pub fn new(client: Arc<C>, pool: Arc<Pool<P>>) -> Self {
-		System {
+impl<P: TransactionPool, C, B> FullSystem<P, C, B> {
+	/// Create new `FullSystem` given client and transaction pool.
+	pub fn new(client: Arc<C>, pool: Arc<P>) -> Self {
+		FullSystem {
 			client,
 			pool,
 			_marker: Default::default(),
@@ -64,74 +78,164 @@ impl<P: ChainApi, C, B> System<P, C, B> {
 	}
 }

-impl<P, C, Block, AccountId, Index> SystemApi<AccountId, Index> for System<P, C, Block>
+impl<P, C, Block, AccountId, Index> SystemApi<AccountId, Index> for FullSystem<P, C, Block>
 where
 	C: traits::ProvideRuntimeApi,
 	C: HeaderBackend<Block>,
 	C: Send + Sync + 'static,
 	C::Api: AccountNonceApi<Block, AccountId, Index>,
-	P: ChainApi + Sync + Send + 'static,
+	P: TransactionPool + 'static,
 	Block: traits::Block,
 	AccountId: Clone + std::fmt::Display + Codec,
-	Index: Clone + std::fmt::Display + Codec + traits::SimpleArithmetic,
+	Index: Clone + std::fmt::Display + Codec + Send + traits::SimpleArithmetic + 'static,
 {
-	fn nonce(&self, account: AccountId) -> Result<Index> {
-		let api = self.client.runtime_api();
-		let best = self.client.info().best_hash;
-		let at = BlockId::hash(best);
+	fn nonce(&self, account: AccountId) -> FutureResult<Index> {
+		let get_nonce = || {
+			let api = self.client.runtime_api();
+			let best = self.client.info().best_hash;
+			let at = BlockId::hash(best);

-		let nonce = api.account_nonce(&at, account.clone()).map_err(|e| Error {
+			let nonce = api.account_nonce(&at, account.clone()).map_err(|e| Error {
+				code: ErrorCode::ServerError(RUNTIME_ERROR),
+				message: "Unable to query nonce.".into(),
+				data: Some(format!("{:?}", e).into()),
+			})?;
+
+			Ok(adjust_nonce(&*self.pool, account, nonce))
+		};
+
+		Box::new(result(get_nonce()))
+	}
+}
+
+/// An implementation of System-specific RPC methods on light client.
+pub struct LightSystem<P: TransactionPool, C, F, Block> {
+	client: Arc<C>,
+	remote_blockchain: Arc<dyn RemoteBlockchain<Block>>,
+	fetcher: Arc<F>,
+	pool: Arc<P>,
+}
+
+impl<P: TransactionPool, C, F, Block> LightSystem<P, C, F, Block> {
+	/// Create new `LightSystem`.
+	pub fn new(
+		client: Arc<C>,
+		remote_blockchain: Arc<dyn RemoteBlockchain<Block>>,
+		fetcher: Arc<F>,
+		pool: Arc<P>,
+	) -> Self {
+		LightSystem {
+			client,
+			remote_blockchain,
+			fetcher,
+			pool,
+		}
+	}
+}
+
+impl<P, C, F, Block, AccountId, Index> SystemApi<AccountId, Index> for LightSystem<P, C, F, Block>
+where
+	P: TransactionPool + 'static,
+	C: HeaderBackend<Block>,
+	C: Send + Sync + 'static,
+	F: Fetcher<Block> + 'static,
+	Block: traits::Block,
+	AccountId: Clone + std::fmt::Display + Codec + Send + 'static,
+	Index: Clone + std::fmt::Display + Codec + Send + traits::SimpleArithmetic + 'static,
+{
+	fn nonce(&self, account: AccountId) -> FutureResult<Index> {
+		let best_hash = self.client.info().best_hash;
+		let best_id = BlockId::hash(best_hash);
+		let future_best_header = future_header(&*self.remote_blockchain, &*self.fetcher, best_id);
+		let fetcher = self.fetcher.clone();
+		let call_data = account.encode();
+		let future_best_header = future_best_header
+			.and_then(move |maybe_best_header| ready(
+				match maybe_best_header {
+					Some(best_header) => Ok(best_header),
+					None => Err(ClientError::UnknownBlock(format!("{}", best_hash))),
+				}
+			));
+		let future_nonce = future_best_header.and_then(move |best_header|
+			fetcher.remote_call(RemoteCallRequest {
+				block: best_hash,
+				header: best_header,
+				method: "AccountNonceApi_account_nonce".into(),
+				call_data,
+				retry_count: None,
+			})
+		).compat();
+		let future_nonce = future_nonce.and_then(|nonce| Decode::decode(&mut &nonce[..])
+			.map_err(|e| ClientError::CallResultDecode("Cannot decode account nonce", e)));
+		let future_nonce = future_nonce.map_err(|e| Error {
 			code: ErrorCode::ServerError(RUNTIME_ERROR),
 			message: "Unable to query nonce.".into(),
 			data: Some(format!("{:?}", e).into()),
-		})?;
+		});

-		log::debug!(target: "rpc", "State nonce for {}: {}", account, nonce);
-		// Now we need to query the transaction pool
-		// and find transactions originating from the same sender.
-		//
-		// Since extrinsics are opaque to us, we look for them using
-		// `provides` tag. And increment the nonce if we find a transaction
-		// that matches the current one.
-		let mut current_nonce = nonce.clone();
-		let mut current_tag = (account.clone(), nonce.clone()).encode();
-		for tx in self.pool.ready() {
-			log::debug!(
-				target: "rpc",
-				"Current nonce to {}, checking {} vs {:?}",
-				current_nonce,
-				HexDisplay::from(&current_tag),
-				tx.provides.iter().map(|x| format!("{}", HexDisplay::from(x))).collect::<Vec<_>>(),
-			);
-			// since transactions in `ready()` need to be ordered by nonce
-			// it's fine to continue with current iterator.
-			if tx.provides.get(0) == Some(&current_tag) {
-				current_nonce += traits::One::one();
-				current_tag = (account.clone(), current_nonce.clone()).encode();
-			}
-		}
+		let pool = self.pool.clone();
+		let future_nonce = future_nonce.map(move |nonce| adjust_nonce(&*pool, account, nonce));

-		Ok(current_nonce)
+		Box::new(future_nonce)
 	}
 }

+/// Adjust account nonce from state, so that tx with the nonce will be
+/// placed after all ready txpool transactions.
+fn adjust_nonce<P, AccountId, Index>(
+	pool: &P,
+	account: AccountId,
+	nonce: Index,
+) -> Index where
+	P: TransactionPool,
+	AccountId: Clone + std::fmt::Display + Encode,
+	Index: Clone + std::fmt::Display + Encode + traits::SimpleArithmetic + 'static,
+{
+	log::debug!(target: "rpc", "State nonce for {}: {}", account, nonce);
+	// Now we need to query the transaction pool
+	// and find transactions originating from the same sender.
+	//
+	// Since extrinsics are opaque to us, we look for them using
+	// `provides` tag. And increment the nonce if we find a transaction
+	// that matches the current one.
+	let mut current_nonce = nonce.clone();
+	let mut current_tag = (account.clone(), nonce.clone()).encode();
+	for tx in pool.ready() {
+		log::debug!(
+			target: "rpc",
+			"Current nonce to {}, checking {} vs {:?}",
+			current_nonce,
+			HexDisplay::from(&current_tag),
+			tx.provides().iter().map(|x| format!("{}", HexDisplay::from(x))).collect::<Vec<_>>(),
+		);
+		// since transactions in `ready()` need to be ordered by nonce
+		// it's fine to continue with current iterator.
+		if tx.provides().get(0) == Some(&current_tag) {
+			current_nonce += traits::One::one();
+			current_tag = (account.clone(), current_nonce.clone()).encode();
+		}
+	}
+
+	current_nonce
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use sc_transaction_pool;

 	use futures::executor::block_on;
 	use test_client::{
 		runtime::Transfer,
 		AccountKeyring,
 	};
+	use txpool::{BasicPool, FullChainApi};

 	#[test]
 	fn should_return_next_nonce_for_some_account() {
 		// given
 		let _ = env_logger::try_init();
 		let client = Arc::new(test_client::new());
-		let pool = Arc::new(Pool::new(Default::default(), sc_transaction_pool::FullChainApi::new(client.clone())));
+		let pool = Arc::new(BasicPool::new(Default::default(), FullChainApi::new(client.clone())));

 		let new_transaction = |nonce: u64| {
 			let t = Transfer {
@@ -148,12 +252,12 @@ mod tests {
 		let ext1 = new_transaction(1);
 		block_on(pool.submit_one(&BlockId::number(0), ext1)).unwrap();

-		let accounts = System::new(client, pool);
+		let accounts = FullSystem::new(client, pool);

 		// when
 		let nonce = accounts.nonce(AccountKeyring::Alice.into());

 		// then
-		assert_eq!(nonce.unwrap(), 2);
+		assert_eq!(nonce.wait().unwrap(), 2);
 	}
 }