,
pool: Arc,
_marker: std::marker::PhantomData,
}
impl FullSystem {
/// Create new `FullSystem` given client and transaction pool.
pub fn new(client: Arc, pool: Arc) -> Self {
FullSystem {
client,
pool,
_marker: Default::default(),
}
}
}
impl SystemApi for FullSystem
where
C: sp_api::ProvideRuntimeApi,
C: HeaderBackend,
C: Send + Sync + 'static,
C::Api: AccountNonceApi,
P: TransactionPool + 'static,
Block: traits::Block,
AccountId: Clone + std::fmt::Display + Codec,
Index: Clone + std::fmt::Display + Codec + Send + traits::AtLeast32Bit + 'static,
{
fn nonce(&self, account: AccountId) -> FutureResult {
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 {
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 {
client: Arc,
remote_blockchain: Arc>,
fetcher: Arc,
pool: Arc,
}
impl LightSystem {
/// Create new `LightSystem`.
pub fn new(
client: Arc,
remote_blockchain: Arc>,
fetcher: Arc,
pool: Arc,
) -> Self {
LightSystem {
client,
remote_blockchain,
fetcher,
pool,
}
}
}
impl SystemApi for LightSystem
where
P: TransactionPool + 'static,
C: HeaderBackend,
C: Send + Sync + 'static,
F: Fetcher + 'static,
Block: traits::Block,
AccountId: Clone + std::fmt::Display + Codec + Send + 'static,
Index: Clone + std::fmt::Display + Codec + Send + traits::AtLeast32Bit + 'static,
{
fn nonce(&self, account: AccountId) -> FutureResult {
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()),
});
let pool = self.pool.clone();
let future_nonce = future_nonce.map(move |nonce| adjust_nonce(&*pool, account, 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(
pool: &P,
account: AccountId,
nonce: Index,
) -> Index where
P: TransactionPool,
AccountId: Clone + std::fmt::Display + Encode,
Index: Clone + std::fmt::Display + Encode + traits::AtLeast32Bit + '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(¤t_tag),
tx.provides().iter().map(|x| format!("{}", HexDisplay::from(x))).collect::>(),
);
// since transactions in `ready()` need to be ordered by nonce
// it's fine to continue with current iterator.
if tx.provides().get(0) == Some(¤t_tag) {
current_nonce += traits::One::one();
current_tag = (account.clone(), current_nonce.clone()).encode();
}
}
current_nonce
}
#[cfg(test)]
mod tests {
use super::*;
use futures::executor::block_on;
use substrate_test_runtime_client::{
runtime::Transfer,
AccountKeyring,
};
use sc_transaction_pool::{BasicPool, FullChainApi};
#[test]
fn should_return_next_nonce_for_some_account() {
// given
let _ = env_logger::try_init();
let client = Arc::new(substrate_test_runtime_client::new());
let pool = Arc::new(
BasicPool::new(Default::default(), Arc::new(FullChainApi::new(client.clone()))).0
);
let new_transaction = |nonce: u64| {
let t = Transfer {
from: AccountKeyring::Alice.into(),
to: AccountKeyring::Bob.into(),
amount: 5,
nonce,
};
t.into_signed_tx()
};
// Populate the pool
let ext0 = new_transaction(0);
block_on(pool.submit_one(&BlockId::number(0), ext0)).unwrap();
let ext1 = new_transaction(1);
block_on(pool.submit_one(&BlockId::number(0), ext1)).unwrap();
let accounts = FullSystem::new(client, pool);
// when
let nonce = accounts.nonce(AccountKeyring::Alice.into());
// then
assert_eq!(nonce.wait().unwrap(), 2);
}
}