mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-06-13 10:31:04 +00:00
Remove all (non-dev) client references from frame, activate dependency enforcer (#4184)
* Move transaction pool to primitives * move backend, errors into primitives * remove unused client depencies * Move rpc-api into primitives * Move peerset back to client * Move rpc/api back to client, move palette/support/rpc into utils * move support-rpc into subfolder * move system-rpc into utils * move transaction-pool and -graph back into client * fix broken imports * Clean up test primitives * Make support test utils independent of frame * remove unnecessary node dependencies from service * Reactivate dependency script: - only enforce the now achieved status quo will remain - allow for primitives to depend on /client for now without failing - more discriptive error message so people understand, what it wants - minor fix to differentiative between ../client and /client (which may be a subfolder) - don't allow this to fail anylonger. * fix doc comment * 'Should not' rather than 'must not'. * Revert unwanted dependency changes * fix faulty import * fixup derive_more version * fix wrong import path
This commit is contained in:
Benjamin Kampmann
committed by
GitHub
GitHub
parent
b2aab98e69
commit
bd652793db
@@ -0,0 +1,19 @@
|
||||
[package]
|
||||
name = "substrate-frame-rpc-support"
|
||||
version = "2.0.0"
|
||||
authors = ["Parity Technologies <admin@parity.io>", "Andrew Dirksen <andrew@dirksen.com>"]
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
futures = { version = "0.3.0", features = ["compat"] }
|
||||
jsonrpc-client-transports = "14"
|
||||
jsonrpc-core = "14"
|
||||
parity-scale-codec = "1"
|
||||
serde = "1"
|
||||
frame-support = { path = "../../../../frame/support" }
|
||||
substrate-primitives-storage = { path = "../../../../primitives/core/storage" }
|
||||
sc-rpc-api = { path = "../../../../client/rpc/api" }
|
||||
|
||||
[dev-dependencies]
|
||||
frame-system = { path = "../../../../frame/system" }
|
||||
tokio = "0.1"
|
||||
@@ -0,0 +1,155 @@
|
||||
// Copyright 2019 Parity Technologies (UK) Ltd.
|
||||
// This file is part of Substrate.
|
||||
|
||||
// Substrate is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Substrate is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
//! Combines [sc_rpc_api::state::StateClient] with [frame_support::storage::generator] traits
|
||||
//! to provide strongly typed chain state queries over rpc.
|
||||
|
||||
#![warn(missing_docs)]
|
||||
|
||||
use core::marker::PhantomData;
|
||||
use futures::compat::Future01CompatExt;
|
||||
use jsonrpc_client_transports::RpcError;
|
||||
use parity_scale_codec::{DecodeAll, FullCodec, FullEncode};
|
||||
use serde::{de::DeserializeOwned, Serialize};
|
||||
use frame_support::storage::generator::{
|
||||
StorageDoubleMap, StorageLinkedMap, StorageMap, StorageValue
|
||||
};
|
||||
use substrate_primitives_storage::{StorageData, StorageKey};
|
||||
use sc_rpc_api::state::StateClient;
|
||||
|
||||
/// A typed query on chain state usable from an RPC client.
|
||||
///
|
||||
/// ```no_run
|
||||
/// # use futures::compat::Compat;
|
||||
/// # use futures::compat::Future01CompatExt;
|
||||
/// # use futures::future::FutureExt;
|
||||
/// # use jsonrpc_client_transports::RpcError;
|
||||
/// # use jsonrpc_client_transports::transports::http;
|
||||
/// # use parity_scale_codec::Encode;
|
||||
/// # use frame_support::{decl_storage, decl_module};
|
||||
/// # use substrate_frame_rpc_support::StorageQuery;
|
||||
/// # use frame_system::Trait;
|
||||
/// # use sc_rpc_api::state::StateClient;
|
||||
/// #
|
||||
/// # // Hash would normally be <TestRuntime as frame_system::Trait>::Hash, but we don't have
|
||||
/// # // frame_system::Trait implemented for TestRuntime. Here we just pretend.
|
||||
/// # type Hash = ();
|
||||
/// #
|
||||
/// # fn main() -> Result<(), RpcError> {
|
||||
/// # tokio::runtime::Runtime::new().unwrap().block_on(Compat::new(test().boxed()))
|
||||
/// # }
|
||||
/// #
|
||||
/// # struct TestRuntime;
|
||||
/// #
|
||||
/// # decl_module! {
|
||||
/// # pub struct Module<T: Trait> for enum Call where origin: T::Origin {}
|
||||
/// # }
|
||||
/// #
|
||||
/// pub type Loc = (i64, i64, i64);
|
||||
/// pub type Block = u8;
|
||||
///
|
||||
/// // Note that all fields are marked pub.
|
||||
/// decl_storage! {
|
||||
/// trait Store for Module<T: Trait> as TestRuntime {
|
||||
/// pub LastActionId: u64;
|
||||
/// pub Voxels: map Loc => Block;
|
||||
/// pub Actions: linked_map u64 => Loc;
|
||||
/// pub Prefab: double_map u128, blake2_256((i8, i8, i8)) => Block;
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// # async fn test() -> Result<(), RpcError> {
|
||||
/// let conn = http::connect("http://[::1]:9933").compat().await?;
|
||||
/// let cl = StateClient::<Hash>::new(conn);
|
||||
///
|
||||
/// let q = StorageQuery::value::<LastActionId>();
|
||||
/// let _: Option<u64> = q.get(&cl, None).await?;
|
||||
///
|
||||
/// let q = StorageQuery::map::<Voxels, _>((0, 0, 0));
|
||||
/// let _: Option<Block> = q.get(&cl, None).await?;
|
||||
///
|
||||
/// let q = StorageQuery::linked_map::<Actions, _>(12);
|
||||
/// let _: Option<Loc> = q.get(&cl, None).await?;
|
||||
///
|
||||
/// let q = StorageQuery::double_map::<Prefab, _, _>(3, (0, 0, 0));
|
||||
/// let _: Option<Block> = q.get(&cl, None).await?;
|
||||
/// #
|
||||
/// # Ok(())
|
||||
/// # }
|
||||
/// ```
|
||||
#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
|
||||
pub struct StorageQuery<V> {
|
||||
key: StorageKey,
|
||||
_spook: PhantomData<V>,
|
||||
}
|
||||
|
||||
impl<V: FullCodec> StorageQuery<V> {
|
||||
/// Create a storage query for a StorageValue.
|
||||
pub fn value<St: StorageValue<V>>() -> Self {
|
||||
Self {
|
||||
key: StorageKey(St::storage_value_final_key().to_vec()),
|
||||
_spook: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a storage query for a value in a StorageMap.
|
||||
pub fn map<St: StorageMap<K, V>, K: FullEncode>(key: K) -> Self {
|
||||
Self {
|
||||
key: StorageKey(St::storage_map_final_key(key).as_ref().to_vec()),
|
||||
_spook: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a storage query for a value in a StorageLinkedMap.
|
||||
pub fn linked_map<St: StorageLinkedMap<K, V>, K: FullCodec>(key: K) -> Self {
|
||||
Self {
|
||||
key: StorageKey(St::storage_linked_map_final_key(key).as_ref().to_vec()),
|
||||
_spook: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a storage query for a value in a StorageDoubleMap.
|
||||
pub fn double_map<St: StorageDoubleMap<K1, K2, V>, K1: FullEncode, K2: FullEncode>(
|
||||
key1: K1,
|
||||
key2: K2,
|
||||
) -> Self {
|
||||
Self {
|
||||
key: StorageKey(St::storage_double_map_final_key(key1, key2)),
|
||||
_spook: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
/// Send this query over RPC, await the typed result.
|
||||
///
|
||||
/// Hash should be <YourRuntime as frame::Trait>::Hash.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// state_client represents a connection to the RPC server.
|
||||
///
|
||||
/// block_index indicates the block for which state will be queried. A value of None indicates
|
||||
/// the latest block.
|
||||
pub async fn get<Hash: Send + Sync + 'static + DeserializeOwned + Serialize>(
|
||||
self,
|
||||
state_client: &StateClient<Hash>,
|
||||
block_index: Option<Hash>,
|
||||
) -> Result<Option<V>, RpcError> {
|
||||
let opt: Option<StorageData> = state_client.storage(self.key, block_index).compat().await?;
|
||||
opt.map(|encoded| V::decode_all(&encoded.0))
|
||||
.transpose()
|
||||
.map_err(|decode_err| RpcError::Other(decode_err.into()))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
[package]
|
||||
name = "substrate-frame-rpc-system"
|
||||
version = "2.0.0"
|
||||
authors = ["Parity Technologies <admin@parity.io>"]
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
codec = { package = "parity-scale-codec", version = "1.0.0" }
|
||||
jsonrpc-core = "14.0.3"
|
||||
jsonrpc-core-client = "14.0.3"
|
||||
jsonrpc-derive = "14.0.3"
|
||||
log = "0.4.8"
|
||||
serde = { version = "1.0.101", features = ["derive"] }
|
||||
sr-primitives = { path = "../../../../primitives/sr-primitives" }
|
||||
frame-system-rpc-runtime-api = { path = "../../../../frame/system/rpc/runtime-api" }
|
||||
substrate-primitives = { path = "../../../../primitives/core" }
|
||||
sp-blockchain = { path = "../../../../primitives/blockchain" }
|
||||
sc-transaction-graph = { path = "../../../../client/transaction-pool/graph" }
|
||||
|
||||
[dev-dependencies]
|
||||
test-client = { package = "substrate-test-runtime-client", path = "../../../../test/utils/runtime/client" }
|
||||
sc-transaction-pool = { path = "../../../../client/transaction-pool" }
|
||||
env_logger = "0.7.0"
|
||||
futures = "0.3.1"
|
||||
@@ -0,0 +1,159 @@
|
||||
// Copyright 2019 Parity Technologies (UK) Ltd.
|
||||
// This file is part of Substrate.
|
||||
|
||||
// Substrate is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Substrate is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
//! System SRML specific RPC methods.
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use codec::{self, Codec, Encode};
|
||||
use sp_blockchain::HeaderBackend;
|
||||
use jsonrpc_core::{Result, Error, ErrorCode};
|
||||
use jsonrpc_derive::rpc;
|
||||
use sr_primitives::{
|
||||
generic::BlockId,
|
||||
traits,
|
||||
};
|
||||
use substrate_primitives::hexdisplay::HexDisplay;
|
||||
use sc_transaction_graph::{self, ChainApi, Pool};
|
||||
|
||||
pub use frame_system_rpc_runtime_api::AccountNonceApi;
|
||||
pub use self::gen_client::Client as SystemClient;
|
||||
|
||||
/// System RPC methods.
|
||||
#[rpc]
|
||||
pub trait SystemApi<AccountId, Index> {
|
||||
/// Returns the next valid index (aka nonce) for given account.
|
||||
///
|
||||
/// This method takes into consideration all pending transactions
|
||||
/// 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>;
|
||||
}
|
||||
|
||||
const RUNTIME_ERROR: i64 = 1;
|
||||
|
||||
/// An implementation of System-specific RPC methods.
|
||||
pub struct System<P: ChainApi, C, B> {
|
||||
client: Arc<C>,
|
||||
pool: Arc<Pool<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 {
|
||||
client,
|
||||
pool,
|
||||
_marker: Default::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<P, C, Block, AccountId, Index> SystemApi<AccountId, Index> for System<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,
|
||||
Block: traits::Block,
|
||||
AccountId: Clone + std::fmt::Display + Codec,
|
||||
Index: Clone + std::fmt::Display + Codec + traits::SimpleArithmetic,
|
||||
{
|
||||
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);
|
||||
|
||||
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()),
|
||||
})?;
|
||||
|
||||
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(¤t_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(¤t_tag) {
|
||||
current_nonce += traits::One::one();
|
||||
current_tag = (account.clone(), current_nonce.clone()).encode();
|
||||
}
|
||||
}
|
||||
|
||||
Ok(current_nonce)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use sc_transaction_pool;
|
||||
|
||||
use futures::executor::block_on;
|
||||
use test_client::{
|
||||
runtime::Transfer,
|
||||
AccountKeyring,
|
||||
};
|
||||
|
||||
#[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 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 = System::new(client, pool);
|
||||
|
||||
// when
|
||||
let nonce = accounts.nonce(AccountKeyring::Alice.into());
|
||||
|
||||
// then
|
||||
assert_eq!(nonce.unwrap(), 2);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user