use std::sync::Arc;
use codec::{self, Codec, Decode, Encode};
use sc_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 sp_runtime::{
generic::BlockId,
traits,
};
use sp_core::hexdisplay::HexDisplay;
use sp_transaction_pool::{TransactionPool, InPoolTransaction};
pub use frame_system_rpc_runtime_api::AccountNonceApi;
pub use self::gen_client::Client as SystemClient;
pub type FutureResult<T> = Box<dyn Future<Item = T, Error = Error> + Send>;
#[rpc]
pub trait SystemApi<AccountId, Index> {
#[rpc(name = "system_accountNextIndex", alias("account_nextIndex"))]
fn nonce(&self, account: AccountId) -> FutureResult<Index>;
}
const RUNTIME_ERROR: i64 = 1;
pub struct FullSystem<P: TransactionPool, C, B> {
client: Arc<C>,
pool: Arc<P>,
_marker: std::marker::PhantomData<B>,
}
impl<P: TransactionPool, C, B> FullSystem<P, C, B> {
pub fn new(client: Arc<C>, pool: Arc<P>) -> Self {
FullSystem {
client,
pool,
_marker: Default::default(),
}
}
}
impl<P, C, Block, AccountId, Index> SystemApi<AccountId, Index> for FullSystem<P, C, Block>
where
C: sp_api::ProvideRuntimeApi<Block>,
C: HeaderBackend<Block>,
C: Send + Sync + 'static,
C::Api: AccountNonceApi<Block, AccountId, Index>,
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<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 {
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()))
}
}
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> {
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::AtLeast32Bit + '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()),
});
let pool = self.pool.clone();
let future_nonce = future_nonce.map(move |nonce| adjust_nonce(&*pool, account, nonce));
Box::new(future_nonce)
}
}
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::AtLeast32Bit + 'static,
{
log::debug!(target: "rpc", "State nonce for {}: {}", account, nonce);
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::<Vec<_>>(),
);
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() {
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()
};
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);
let nonce = accounts.nonce(AccountKeyring::Alice.into());
assert_eq!(nonce.wait().unwrap(), 2);
}
}