From 87de1e7e0d6bf2f78894f59110234d4e4e0ace53 Mon Sep 17 00:00:00 2001
From: Alexandru Vasile <60601340+lexnv@users.noreply.github.com>
Date: Fri, 20 May 2022 22:16:35 +0300
Subject: [PATCH] RPC: Mark storage methods as `blocking` (#11459)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
* client/api: Make `storage_keys` blocking
Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
* client/api: Ensure `state_*` RPC methods are blocking
Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
* client/rpc: Ensure `childstate_*` RPC methods are blocking
Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
* client/rpc: `ChainApi` make RPC methods sync
Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
* Remove unused async-traits
Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
* client/rpc-api: Make chain RPC methods blocking
Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
* Update client/rpc/src/state/state_full.rs
Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>
* Add `blocking` to `state_getKeysPaged` RPC call
Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
* Fix build and warning
Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
* Remove `async_trait` tidyup
Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
Co-authored-by: Bastian Köcher <bkchr@users.noreply.github.com>
---
substrate/client/rpc-api/src/chain/mod.rs | 12 +-
.../client/rpc-api/src/child_state/mod.rs | 28 ++--
substrate/client/rpc-api/src/state/mod.rs | 60 ++++----
substrate/client/rpc/src/chain/chain_full.rs | 7 +-
substrate/client/rpc/src/chain/mod.rs | 19 +--
substrate/client/rpc/src/state/mod.rs | 136 ++++++++----------
substrate/client/rpc/src/state/state_full.rs | 65 ++++-----
substrate/client/rpc/src/state/tests.rs | 60 +++-----
8 files changed, 164 insertions(+), 223 deletions(-)
diff --git a/substrate/client/rpc-api/src/chain/mod.rs b/substrate/client/rpc-api/src/chain/mod.rs
index f5f9524264e..c7cc9746398 100644
--- a/substrate/client/rpc-api/src/chain/mod.rs
+++ b/substrate/client/rpc-api/src/chain/mod.rs
@@ -26,24 +26,24 @@ pub mod error;
#[rpc(client, server)]
pub trait ChainApi<Number, Hash, Header, SignedBlock> {
/// Get header.
- #[method(name = "chain_getHeader")]
- async fn header(&self, hash: Option<Hash>) -> RpcResult<Option<Header>>;
+ #[method(name = "chain_getHeader", blocking)]
+ fn header(&self, hash: Option<Hash>) -> RpcResult<Option<Header>>;
/// Get header and body of a relay chain block.
- #[method(name = "chain_getBlock")]
- async fn block(&self, hash: Option<Hash>) -> RpcResult<Option<SignedBlock>>;
+ #[method(name = "chain_getBlock", blocking)]
+ fn block(&self, hash: Option<Hash>) -> RpcResult<Option<SignedBlock>>;
/// Get hash of the n-th block in the canon chain.
///
/// By default returns latest block hash.
- #[method(name = "chain_getBlockHash", aliases = ["chain_getHead"])]
+ #[method(name = "chain_getBlockHash", aliases = ["chain_getHead"], blocking)]
fn block_hash(
&self,
hash: Option<ListOrValue<NumberOrHex>>,
) -> RpcResult<ListOrValue<Option<Hash>>>;
/// Get hash of the last finalized block in the canon chain.
- #[method(name = "chain_getFinalizedHead", aliases = ["chain_getFinalisedHead"])]
+ #[method(name = "chain_getFinalizedHead", aliases = ["chain_getFinalisedHead"], blocking)]
fn finalized_head(&self) -> RpcResult<Hash>;
/// All head subscription.
diff --git a/substrate/client/rpc-api/src/child_state/mod.rs b/substrate/client/rpc-api/src/child_state/mod.rs
index a15b1a0e7ee..be279a97463 100644
--- a/substrate/client/rpc-api/src/child_state/mod.rs
+++ b/substrate/client/rpc-api/src/child_state/mod.rs
@@ -28,9 +28,9 @@ use sp_core::storage::{PrefixedStorageKey, StorageData, StorageKey};
#[rpc(client, server)]
pub trait ChildStateApi<Hash> {
/// Returns the keys with prefix from a child storage, leave empty to get all the keys
- #[method(name = "childstate_getKeys")]
+ #[method(name = "childstate_getKeys", blocking)]
#[deprecated(since = "2.0.0", note = "Please use `getKeysPaged` with proper paging support")]
- async fn storage_keys(
+ fn storage_keys(
&self,
child_storage_key: PrefixedStorageKey,
prefix: StorageKey,
@@ -40,8 +40,8 @@ pub trait ChildStateApi<Hash> {
/// Returns the keys with prefix from a child storage with pagination support.
/// Up to `count` keys will be returned.
/// If `start_key` is passed, return next keys in storage in lexicographic order.
- #[method(name = "childstate_getKeysPaged", aliases = ["childstate_getKeysPagedAt"])]
- async fn storage_keys_paged(
+ #[method(name = "childstate_getKeysPaged", aliases = ["childstate_getKeysPagedAt"], blocking)]
+ fn storage_keys_paged(
&self,
child_storage_key: PrefixedStorageKey,
prefix: Option<StorageKey>,
@@ -51,8 +51,8 @@ pub trait ChildStateApi<Hash> {
) -> RpcResult<Vec<StorageKey>>;
/// Returns a child storage entry at a specific block's state.
- #[method(name = "childstate_getStorage")]
- async fn storage(
+ #[method(name = "childstate_getStorage", blocking)]
+ fn storage(
&self,
child_storage_key: PrefixedStorageKey,
key: StorageKey,
@@ -60,8 +60,8 @@ pub trait ChildStateApi<Hash> {
) -> RpcResult<Option<StorageData>>;
/// Returns child storage entries for multiple keys at a specific block's state.
- #[method(name = "childstate_getStorageEntries")]
- async fn storage_entries(
+ #[method(name = "childstate_getStorageEntries", blocking)]
+ fn storage_entries(
&self,
child_storage_key: PrefixedStorageKey,
keys: Vec<StorageKey>,
@@ -69,8 +69,8 @@ pub trait ChildStateApi<Hash> {
) -> RpcResult<Vec<Option<StorageData>>>;
/// Returns the hash of a child storage entry at a block's state.
- #[method(name = "childstate_getStorageHash")]
- async fn storage_hash(
+ #[method(name = "childstate_getStorageHash", blocking)]
+ fn storage_hash(
&self,
child_storage_key: PrefixedStorageKey,
key: StorageKey,
@@ -78,8 +78,8 @@ pub trait ChildStateApi<Hash> {
) -> RpcResult<Option<Hash>>;
/// Returns the size of a child storage entry at a block's state.
- #[method(name = "childstate_getStorageSize")]
- async fn storage_size(
+ #[method(name = "childstate_getStorageSize", blocking)]
+ fn storage_size(
&self,
child_storage_key: PrefixedStorageKey,
key: StorageKey,
@@ -87,8 +87,8 @@ pub trait ChildStateApi<Hash> {
) -> RpcResult<Option<u64>>;
/// Returns proof of storage for child key entries at a specific block's state.
- #[method(name = "state_getChildReadProof")]
- async fn read_child_proof(
+ #[method(name = "state_getChildReadProof", blocking)]
+ fn read_child_proof(
&self,
child_storage_key: PrefixedStorageKey,
keys: Vec<StorageKey>,
diff --git a/substrate/client/rpc-api/src/state/mod.rs b/substrate/client/rpc-api/src/state/mod.rs
index fba023e8302..54bf21674a8 100644
--- a/substrate/client/rpc-api/src/state/mod.rs
+++ b/substrate/client/rpc-api/src/state/mod.rs
@@ -34,21 +34,17 @@ pub use self::helpers::ReadProof;
#[rpc(client, server)]
pub trait StateApi<Hash> {
/// Call a contract at a block's state.
- #[method(name = "state_call", aliases = ["state_callAt"])]
- async fn call(&self, name: String, bytes: Bytes, hash: Option<Hash>) -> RpcResult<Bytes>;
+ #[method(name = "state_call", aliases = ["state_callAt"], blocking)]
+ fn call(&self, name: String, bytes: Bytes, hash: Option<Hash>) -> RpcResult<Bytes>;
/// Returns the keys with prefix, leave empty to get all the keys.
- #[method(name = "state_getKeys")]
+ #[method(name = "state_getKeys", blocking)]
#[deprecated(since = "2.0.0", note = "Please use `getKeysPaged` with proper paging support")]
- async fn storage_keys(
- &self,
- prefix: StorageKey,
- hash: Option<Hash>,
- ) -> RpcResult<Vec<StorageKey>>;
+ fn storage_keys(&self, prefix: StorageKey, hash: Option<Hash>) -> RpcResult<Vec<StorageKey>>;
/// Returns the keys with prefix, leave empty to get all the keys
- #[method(name = "state_getPairs")]
- async fn storage_pairs(
+ #[method(name = "state_getPairs", blocking)]
+ fn storage_pairs(
&self,
prefix: StorageKey,
hash: Option<Hash>,
@@ -57,8 +53,8 @@ pub trait StateApi<Hash> {
/// Returns the keys with prefix with pagination support.
/// Up to `count` keys will be returned.
/// If `start_key` is passed, return next keys in storage in lexicographic order.
- #[method(name = "state_getKeysPaged", aliases = ["state_getKeysPagedAt"])]
- async fn storage_keys_paged(
+ #[method(name = "state_getKeysPaged", aliases = ["state_getKeysPagedAt"], blocking)]
+ fn storage_keys_paged(
&self,
prefix: Option<StorageKey>,
count: u32,
@@ -67,32 +63,32 @@ pub trait StateApi<Hash> {
) -> RpcResult<Vec<StorageKey>>;
/// Returns a storage entry at a specific block's state.
- #[method(name = "state_getStorage", aliases = ["state_getStorageAt"])]
- async fn storage(&self, key: StorageKey, hash: Option<Hash>) -> RpcResult<Option<StorageData>>;
+ #[method(name = "state_getStorage", aliases = ["state_getStorageAt"], blocking)]
+ fn storage(&self, key: StorageKey, hash: Option<Hash>) -> RpcResult<Option<StorageData>>;
/// Returns the hash of a storage entry at a block's state.
- #[method(name = "state_getStorageHash", aliases = ["state_getStorageHashAt"])]
- async fn storage_hash(&self, key: StorageKey, hash: Option<Hash>) -> RpcResult<Option<Hash>>;
+ #[method(name = "state_getStorageHash", aliases = ["state_getStorageHashAt"], blocking)]
+ fn storage_hash(&self, key: StorageKey, hash: Option<Hash>) -> RpcResult<Option<Hash>>;
/// Returns the size of a storage entry at a block's state.
- #[method(name = "state_getStorageSize", aliases = ["state_getStorageSizeAt"])]
- async fn storage_size(&self, key: StorageKey, hash: Option<Hash>) -> RpcResult<Option<u64>>;
+ #[method(name = "state_getStorageSize", aliases = ["state_getStorageSizeAt"], blocking)]
+ fn storage_size(&self, key: StorageKey, hash: Option<Hash>) -> RpcResult<Option<u64>>;
/// Returns the runtime metadata as an opaque blob.
- #[method(name = "state_getMetadata")]
- async fn metadata(&self, hash: Option<Hash>) -> RpcResult<Bytes>;
+ #[method(name = "state_getMetadata", blocking)]
+ fn metadata(&self, hash: Option<Hash>) -> RpcResult<Bytes>;
/// Get the runtime version.
- #[method(name = "state_getRuntimeVersion", aliases = ["chain_getRuntimeVersion"])]
- async fn runtime_version(&self, hash: Option<Hash>) -> RpcResult<RuntimeVersion>;
+ #[method(name = "state_getRuntimeVersion", aliases = ["chain_getRuntimeVersion"], blocking)]
+ fn runtime_version(&self, hash: Option<Hash>) -> RpcResult<RuntimeVersion>;
/// Query historical storage entries (by key) starting from a block given as the second
/// parameter.
///
/// NOTE This first returned result contains the initial state of storage for all keys.
/// Subsequent values in the vector represent changes to the previous state (diffs).
- #[method(name = "state_queryStorage")]
- async fn query_storage(
+ #[method(name = "state_queryStorage", blocking)]
+ fn query_storage(
&self,
keys: Vec<StorageKey>,
block: Hash,
@@ -100,20 +96,16 @@ pub trait StateApi<Hash> {
) -> RpcResult<Vec<StorageChangeSet<Hash>>>;
/// Query storage entries (by key) starting at block hash given as the second parameter.
- #[method(name = "state_queryStorageAt")]
- async fn query_storage_at(
+ #[method(name = "state_queryStorageAt", blocking)]
+ fn query_storage_at(
&self,
keys: Vec<StorageKey>,
at: Option<Hash>,
) -> RpcResult<Vec<StorageChangeSet<Hash>>>;
/// Returns proof of storage entries at a specific block's state.
- #[method(name = "state_getReadProof")]
- async fn read_proof(
- &self,
- keys: Vec<StorageKey>,
- hash: Option<Hash>,
- ) -> RpcResult<ReadProof<Hash>>;
+ #[method(name = "state_getReadProof", blocking)]
+ fn read_proof(&self, keys: Vec<StorageKey>, hash: Option<Hash>) -> RpcResult<ReadProof<Hash>>;
/// New runtime version subscription
#[subscription(
@@ -285,8 +277,8 @@ pub trait StateApi<Hash> {
///
/// If you are having issues with maximum payload size you can use the flag
/// `-ltracing=trace` to get some logging during tracing.
- #[method(name = "state_traceBlock")]
- async fn trace_block(
+ #[method(name = "state_traceBlock", blocking)]
+ fn trace_block(
&self,
block: Hash,
targets: Option<String>,
diff --git a/substrate/client/rpc/src/chain/chain_full.rs b/substrate/client/rpc/src/chain/chain_full.rs
index 2d507f7b9b6..c00c6e5875d 100644
--- a/substrate/client/rpc/src/chain/chain_full.rs
+++ b/substrate/client/rpc/src/chain/chain_full.rs
@@ -26,7 +26,7 @@ use futures::{
future::{self, FutureExt},
stream::{self, Stream, StreamExt},
};
-use jsonrpsee::{core::async_trait, PendingSubscription};
+use jsonrpsee::PendingSubscription;
use sc_client_api::{BlockBackend, BlockchainEvents};
use sp_blockchain::HeaderBackend;
use sp_runtime::{
@@ -51,7 +51,6 @@ impl<Block: BlockT, Client> FullChain<Block, Client> {
}
}
-#[async_trait]
impl<Block, Client> ChainBackend<Client, Block> for FullChain<Block, Client>
where
Block: BlockT + 'static,
@@ -62,11 +61,11 @@ where
&self.client
}
- async fn header(&self, hash: Option<Block::Hash>) -> Result<Option<Block::Header>, Error> {
+ fn header(&self, hash: Option<Block::Hash>) -> Result<Option<Block::Header>, Error> {
self.client.header(BlockId::Hash(self.unwrap_or_best(hash))).map_err(client_err)
}
- async fn block(&self, hash: Option<Block::Hash>) -> Result<Option<SignedBlock<Block>>, Error> {
+ fn block(&self, hash: Option<Block::Hash>) -> Result<Option<SignedBlock<Block>>, Error> {
self.client.block(&BlockId::Hash(self.unwrap_or_best(hash))).map_err(client_err)
}
diff --git a/substrate/client/rpc/src/chain/mod.rs b/substrate/client/rpc/src/chain/mod.rs
index a79c66e0a18..a300c80271f 100644
--- a/substrate/client/rpc/src/chain/mod.rs
+++ b/substrate/client/rpc/src/chain/mod.rs
@@ -27,10 +27,7 @@ use std::sync::Arc;
use crate::SubscriptionTaskExecutor;
-use jsonrpsee::{
- core::{async_trait, RpcResult},
- PendingSubscription,
-};
+use jsonrpsee::{core::RpcResult, PendingSubscription};
use sc_client_api::BlockchainEvents;
use sp_rpc::{list::ListOrValue, number::NumberOrHex};
use sp_runtime::{
@@ -45,7 +42,6 @@ pub use sc_rpc_api::chain::*;
use sp_blockchain::HeaderBackend;
/// Blockchain backend API
-#[async_trait]
trait ChainBackend<Client, Block: BlockT>: Send + Sync + 'static
where
Block: BlockT + 'static,
@@ -64,10 +60,10 @@ where
}
/// Get header of a relay chain block.
- async fn header(&self, hash: Option<Block::Hash>) -> Result<Option<Block::Header>, Error>;
+ fn header(&self, hash: Option<Block::Hash>) -> Result<Option<Block::Header>, Error>;
/// Get header and body of a relay chain block.
- async fn block(&self, hash: Option<Block::Hash>) -> Result<Option<SignedBlock<Block>>, Error>;
+ fn block(&self, hash: Option<Block::Hash>) -> Result<Option<SignedBlock<Block>>, Error>;
/// Get hash of the n-th block in the canon chain.
///
@@ -126,7 +122,6 @@ pub struct Chain<Block: BlockT, Client> {
backend: Box<dyn ChainBackend<Client, Block>>,
}
-#[async_trait]
impl<Block, Client> ChainApiServer<NumberFor<Block>, Block::Hash, Block::Header, SignedBlock<Block>>
for Chain<Block, Client>
where
@@ -134,12 +129,12 @@ where
Block::Header: Unpin,
Client: HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
{
- async fn header(&self, hash: Option<Block::Hash>) -> RpcResult<Option<Block::Header>> {
- self.backend.header(hash).await.map_err(Into::into)
+ fn header(&self, hash: Option<Block::Hash>) -> RpcResult<Option<Block::Header>> {
+ self.backend.header(hash).map_err(Into::into)
}
- async fn block(&self, hash: Option<Block::Hash>) -> RpcResult<Option<SignedBlock<Block>>> {
- self.backend.block(hash).await.map_err(Into::into)
+ fn block(&self, hash: Option<Block::Hash>) -> RpcResult<Option<SignedBlock<Block>>> {
+ self.backend.block(hash).map_err(Into::into)
}
fn block_hash(
diff --git a/substrate/client/rpc/src/state/mod.rs b/substrate/client/rpc/src/state/mod.rs
index a45651c5e79..4b5b74950a4 100644
--- a/substrate/client/rpc/src/state/mod.rs
+++ b/substrate/client/rpc/src/state/mod.rs
@@ -28,7 +28,7 @@ use std::sync::Arc;
use crate::SubscriptionTaskExecutor;
use jsonrpsee::{
- core::{async_trait, Error as JsonRpseeError, RpcResult},
+ core::{Error as JsonRpseeError, RpcResult},
ws_server::PendingSubscription,
};
@@ -53,14 +53,13 @@ use sp_blockchain::{HeaderBackend, HeaderMetadata};
const STORAGE_KEYS_PAGED_MAX_COUNT: u32 = 1000;
/// State backend API.
-#[async_trait]
pub trait StateBackend<Block: BlockT, Client>: Send + Sync + 'static
where
Block: BlockT + 'static,
Client: Send + Sync + 'static,
{
/// Call runtime method at given block.
- async fn call(
+ fn call(
&self,
block: Option<Block::Hash>,
method: String,
@@ -68,21 +67,21 @@ where
) -> Result<Bytes, Error>;
/// Returns the keys with prefix, leave empty to get all the keys.
- async fn storage_keys(
+ fn storage_keys(
&self,
block: Option<Block::Hash>,
prefix: StorageKey,
) -> Result<Vec<StorageKey>, Error>;
/// Returns the keys with prefix along with their values, leave empty to get all the pairs.
- async fn storage_pairs(
+ fn storage_pairs(
&self,
block: Option<Block::Hash>,
prefix: StorageKey,
) -> Result<Vec<(StorageKey, StorageData)>, Error>;
/// Returns the keys with prefix with pagination support.
- async fn storage_keys_paged(
+ fn storage_keys_paged(
&self,
block: Option<Block::Hash>,
prefix: Option<StorageKey>,
@@ -91,14 +90,14 @@ where
) -> Result<Vec<StorageKey>, Error>;
/// Returns a storage entry at a specific block's state.
- async fn storage(
+ fn storage(
&self,
block: Option<Block::Hash>,
key: StorageKey,
) -> Result<Option<StorageData>, Error>;
/// Returns the hash of a storage entry at a block's state.
- async fn storage_hash(
+ fn storage_hash(
&self,
block: Option<Block::Hash>,
key: StorageKey,
@@ -108,24 +107,24 @@ where
///
/// If data is available at `key`, it is returned. Else, the sum of values who's key has `key`
/// prefix is returned, i.e. all the storage (double) maps that have this prefix.
- async fn storage_size(
+ fn storage_size(
&self,
block: Option<Block::Hash>,
key: StorageKey,
) -> Result<Option<u64>, Error>;
/// Returns the runtime metadata as an opaque blob.
- async fn metadata(&self, block: Option<Block::Hash>) -> Result<Bytes, Error>;
+ fn metadata(&self, block: Option<Block::Hash>) -> Result<Bytes, Error>;
/// Get the runtime version.
- async fn runtime_version(&self, block: Option<Block::Hash>) -> Result<RuntimeVersion, Error>;
+ fn runtime_version(&self, block: Option<Block::Hash>) -> Result<RuntimeVersion, Error>;
/// Query historical storage entries (by key) starting from a block given as the second
/// parameter.
///
/// NOTE This first returned result contains the initial state of storage for all keys.
/// Subsequent values in the vector represent changes to the previous state (diffs).
- async fn query_storage(
+ fn query_storage(
&self,
from: Block::Hash,
to: Option<Block::Hash>,
@@ -133,21 +132,21 @@ where
) -> Result<Vec<StorageChangeSet<Block::Hash>>, Error>;
/// Query storage entries (by key) starting at block hash given as the second parameter.
- async fn query_storage_at(
+ fn query_storage_at(
&self,
keys: Vec<StorageKey>,
at: Option<Block::Hash>,
) -> Result<Vec<StorageChangeSet<Block::Hash>>, Error>;
/// Returns proof of storage entries at a specific block's state.
- async fn read_proof(
+ fn read_proof(
&self,
block: Option<Block::Hash>,
keys: Vec<StorageKey>,
) -> Result<ReadProof<Block::Hash>, Error>;
/// Trace storage changes for block
- async fn trace_block(
+ fn trace_block(
&self,
block: Block::Hash,
targets: Option<String>,
@@ -203,39 +202,33 @@ pub struct StateApi<Block, Client> {
deny_unsafe: DenyUnsafe,
}
-#[async_trait]
impl<Block, Client> StateApiServer<Block::Hash> for StateApi<Block, Client>
where
Block: BlockT + 'static,
Client: Send + Sync + 'static,
{
- async fn call(
- &self,
- method: String,
- data: Bytes,
- block: Option<Block::Hash>,
- ) -> RpcResult<Bytes> {
- self.backend.call(block, method, data).await.map_err(Into::into)
+ fn call(&self, method: String, data: Bytes, block: Option<Block::Hash>) -> RpcResult<Bytes> {
+ self.backend.call(block, method, data).map_err(Into::into)
}
- async fn storage_keys(
+ fn storage_keys(
&self,
key_prefix: StorageKey,
block: Option<Block::Hash>,
) -> RpcResult<Vec<StorageKey>> {
- self.backend.storage_keys(block, key_prefix).await.map_err(Into::into)
+ self.backend.storage_keys(block, key_prefix).map_err(Into::into)
}
- async fn storage_pairs(
+ fn storage_pairs(
&self,
key_prefix: StorageKey,
block: Option<Block::Hash>,
) -> RpcResult<Vec<(StorageKey, StorageData)>> {
self.deny_unsafe.check_if_safe()?;
- self.backend.storage_pairs(block, key_prefix).await.map_err(Into::into)
+ self.backend.storage_pairs(block, key_prefix).map_err(Into::into)
}
- async fn storage_keys_paged(
+ fn storage_keys_paged(
&self,
prefix: Option<StorageKey>,
count: u32,
@@ -250,66 +243,61 @@ where
}
self.backend
.storage_keys_paged(block, prefix, count, start_key)
- .await
.map_err(Into::into)
}
- async fn storage(
+ fn storage(
&self,
key: StorageKey,
block: Option<Block::Hash>,
) -> RpcResult<Option<StorageData>> {
- self.backend.storage(block, key).await.map_err(Into::into)
+ self.backend.storage(block, key).map_err(Into::into)
}
- async fn storage_hash(
+ fn storage_hash(
&self,
key: StorageKey,
block: Option<Block::Hash>,
) -> RpcResult<Option<Block::Hash>> {
- self.backend.storage_hash(block, key).await.map_err(Into::into)
+ self.backend.storage_hash(block, key).map_err(Into::into)
}
- async fn storage_size(
- &self,
- key: StorageKey,
- block: Option<Block::Hash>,
- ) -> RpcResult<Option<u64>> {
- self.backend.storage_size(block, key).await.map_err(Into::into)
+ fn storage_size(&self, key: StorageKey, block: Option<Block::Hash>) -> RpcResult<Option<u64>> {
+ self.backend.storage_size(block, key).map_err(Into::into)
}
- async fn metadata(&self, block: Option<Block::Hash>) -> RpcResult<Bytes> {
- self.backend.metadata(block).await.map_err(Into::into)
+ fn metadata(&self, block: Option<Block::Hash>) -> RpcResult<Bytes> {
+ self.backend.metadata(block).map_err(Into::into)
}
- async fn runtime_version(&self, at: Option<Block::Hash>) -> RpcResult<RuntimeVersion> {
- self.backend.runtime_version(at).await.map_err(Into::into)
+ fn runtime_version(&self, at: Option<Block::Hash>) -> RpcResult<RuntimeVersion> {
+ self.backend.runtime_version(at).map_err(Into::into)
}
- async fn query_storage(
+ fn query_storage(
&self,
keys: Vec<StorageKey>,
from: Block::Hash,
to: Option<Block::Hash>,
) -> RpcResult<Vec<StorageChangeSet<Block::Hash>>> {
self.deny_unsafe.check_if_safe()?;
- self.backend.query_storage(from, to, keys).await.map_err(Into::into)
+ self.backend.query_storage(from, to, keys).map_err(Into::into)
}
- async fn query_storage_at(
+ fn query_storage_at(
&self,
keys: Vec<StorageKey>,
at: Option<Block::Hash>,
) -> RpcResult<Vec<StorageChangeSet<Block::Hash>>> {
- self.backend.query_storage_at(keys, at).await.map_err(Into::into)
+ self.backend.query_storage_at(keys, at).map_err(Into::into)
}
- async fn read_proof(
+ fn read_proof(
&self,
keys: Vec<StorageKey>,
block: Option<Block::Hash>,
) -> RpcResult<ReadProof<Block::Hash>> {
- self.backend.read_proof(block, keys).await.map_err(Into::into)
+ self.backend.read_proof(block, keys).map_err(Into::into)
}
/// Re-execute the given block with the tracing targets given in `targets`
@@ -317,7 +305,7 @@ where
///
/// Note: requires the node to run with `--rpc-methods=Unsafe`.
/// Note: requires runtimes compiled with wasm tracing support, `--features with-tracing`.
- async fn trace_block(
+ fn trace_block(
&self,
block: Block::Hash,
targets: Option<String>,
@@ -327,7 +315,6 @@ where
self.deny_unsafe.check_if_safe()?;
self.backend
.trace_block(block, targets, storage_keys, methods)
- .await
.map_err(Into::into)
}
@@ -348,14 +335,13 @@ where
}
/// Child state backend API.
-#[async_trait]
pub trait ChildStateBackend<Block: BlockT, Client>: Send + Sync + 'static
where
Block: BlockT + 'static,
Client: Send + Sync + 'static,
{
/// Returns proof of storage for a child key entries at a specific block's state.
- async fn read_child_proof(
+ fn read_child_proof(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
@@ -364,7 +350,7 @@ where
/// Returns the keys with prefix from a child storage,
/// leave prefix empty to get all the keys.
- async fn storage_keys(
+ fn storage_keys(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
@@ -372,7 +358,7 @@ where
) -> Result<Vec<StorageKey>, Error>;
/// Returns the keys with prefix from a child storage with pagination support.
- async fn storage_keys_paged(
+ fn storage_keys_paged(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
@@ -382,7 +368,7 @@ where
) -> Result<Vec<StorageKey>, Error>;
/// Returns a child storage entry at a specific block's state.
- async fn storage(
+ fn storage(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
@@ -390,7 +376,7 @@ where
) -> Result<Option<StorageData>, Error>;
/// Returns child storage entries at a specific block's state.
- async fn storage_entries(
+ fn storage_entries(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
@@ -398,7 +384,7 @@ where
) -> Result<Vec<Option<StorageData>>, Error>;
/// Returns the hash of a child storage entry at a block's state.
- async fn storage_hash(
+ fn storage_hash(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
@@ -406,13 +392,13 @@ where
) -> Result<Option<Block::Hash>, Error>;
/// Returns the size of a child storage entry at a block's state.
- async fn storage_size(
+ fn storage_size(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
key: StorageKey,
) -> Result<Option<u64>, Error> {
- self.storage(block, storage_key, key).await.map(|x| x.map(|x| x.0.len() as u64))
+ self.storage(block, storage_key, key).map(|x| x.map(|x| x.0.len() as u64))
}
}
@@ -421,25 +407,21 @@ pub struct ChildState<Block, Client> {
backend: Box<dyn ChildStateBackend<Block, Client>>,
}
-#[async_trait]
impl<Block, Client> ChildStateApiServer<Block::Hash> for ChildState<Block, Client>
where
Block: BlockT + 'static,
Client: Send + Sync + 'static,
{
- async fn storage_keys(
+ fn storage_keys(
&self,
storage_key: PrefixedStorageKey,
key_prefix: StorageKey,
block: Option<Block::Hash>,
) -> RpcResult<Vec<StorageKey>> {
- self.backend
- .storage_keys(block, storage_key, key_prefix)
- .await
- .map_err(Into::into)
+ self.backend.storage_keys(block, storage_key, key_prefix).map_err(Into::into)
}
- async fn storage_keys_paged(
+ fn storage_keys_paged(
&self,
storage_key: PrefixedStorageKey,
prefix: Option<StorageKey>,
@@ -449,47 +431,46 @@ where
) -> RpcResult<Vec<StorageKey>> {
self.backend
.storage_keys_paged(block, storage_key, prefix, count, start_key)
- .await
.map_err(Into::into)
}
- async fn storage(
+ fn storage(
&self,
storage_key: PrefixedStorageKey,
key: StorageKey,
block: Option<Block::Hash>,
) -> RpcResult<Option<StorageData>> {
- self.backend.storage(block, storage_key, key).await.map_err(Into::into)
+ self.backend.storage(block, storage_key, key).map_err(Into::into)
}
- async fn storage_entries(
+ fn storage_entries(
&self,
storage_key: PrefixedStorageKey,
keys: Vec<StorageKey>,
block: Option<Block::Hash>,
) -> RpcResult<Vec<Option<StorageData>>> {
- self.backend.storage_entries(block, storage_key, keys).await.map_err(Into::into)
+ self.backend.storage_entries(block, storage_key, keys).map_err(Into::into)
}
- async fn storage_hash(
+ fn storage_hash(
&self,
storage_key: PrefixedStorageKey,
key: StorageKey,
block: Option<Block::Hash>,
) -> RpcResult<Option<Block::Hash>> {
- self.backend.storage_hash(block, storage_key, key).await.map_err(Into::into)
+ self.backend.storage_hash(block, storage_key, key).map_err(Into::into)
}
- async fn storage_size(
+ fn storage_size(
&self,
storage_key: PrefixedStorageKey,
key: StorageKey,
block: Option<Block::Hash>,
) -> RpcResult<Option<u64>> {
- self.backend.storage_size(block, storage_key, key).await.map_err(Into::into)
+ self.backend.storage_size(block, storage_key, key).map_err(Into::into)
}
- async fn read_child_proof(
+ fn read_child_proof(
&self,
child_storage_key: PrefixedStorageKey,
keys: Vec<StorageKey>,
@@ -497,7 +478,6 @@ where
) -> RpcResult<ReadProof<Block::Hash>> {
self.backend
.read_child_proof(block, child_storage_key, keys)
- .await
.map_err(Into::into)
}
}
diff --git a/substrate/client/rpc/src/state/state_full.rs b/substrate/client/rpc/src/state/state_full.rs
index 0e20832b305..c58638c870a 100644
--- a/substrate/client/rpc/src/state/state_full.rs
+++ b/substrate/client/rpc/src/state/state_full.rs
@@ -28,10 +28,7 @@ use super::{
use crate::SubscriptionTaskExecutor;
use futures::{future, stream, FutureExt, StreamExt};
-use jsonrpsee::{
- core::{async_trait, Error as JsonRpseeError},
- PendingSubscription,
-};
+use jsonrpsee::{core::Error as JsonRpseeError, PendingSubscription};
use sc_client_api::{
Backend, BlockBackend, BlockchainEvents, CallExecutor, ExecutorProvider, ProofProvider,
StorageProvider,
@@ -170,7 +167,6 @@ where
}
}
-#[async_trait]
impl<BE, Block, Client> StateBackend<Block, Client> for FullState<BE, Block, Client>
where
Block: BlockT + 'static,
@@ -190,7 +186,7 @@ where
+ 'static,
Client::Api: Metadata<Block>,
{
- async fn call(
+ fn call(
&self,
block: Option<Block::Hash>,
method: String,
@@ -212,7 +208,7 @@ where
.map_err(client_err)
}
- async fn storage_keys(
+ fn storage_keys(
&self,
block: Option<Block::Hash>,
prefix: StorageKey,
@@ -222,7 +218,7 @@ where
.map_err(client_err)
}
- async fn storage_pairs(
+ fn storage_pairs(
&self,
block: Option<Block::Hash>,
prefix: StorageKey,
@@ -232,7 +228,7 @@ where
.map_err(client_err)
}
- async fn storage_keys_paged(
+ fn storage_keys_paged(
&self,
block: Option<Block::Hash>,
prefix: Option<StorageKey>,
@@ -251,7 +247,7 @@ where
.map_err(client_err)
}
- async fn storage(
+ fn storage(
&self,
block: Option<Block::Hash>,
key: StorageKey,
@@ -261,7 +257,7 @@ where
.map_err(client_err)
}
- async fn storage_size(
+ fn storage_size(
&self,
block: Option<Block::Hash>,
key: StorageKey,
@@ -290,7 +286,7 @@ where
.map_err(client_err)
}
- async fn storage_hash(
+ fn storage_hash(
&self,
block: Option<Block::Hash>,
key: StorageKey,
@@ -300,7 +296,7 @@ where
.map_err(client_err)
}
- async fn metadata(&self, block: Option<Block::Hash>) -> std::result::Result<Bytes, Error> {
+ fn metadata(&self, block: Option<Block::Hash>) -> std::result::Result<Bytes, Error> {
self.block_or_best(block).map_err(client_err).and_then(|block| {
self.client
.runtime_api()
@@ -310,7 +306,7 @@ where
})
}
- async fn runtime_version(
+ fn runtime_version(
&self,
block: Option<Block::Hash>,
) -> std::result::Result<RuntimeVersion, Error> {
@@ -321,7 +317,7 @@ where
})
}
- async fn query_storage(
+ fn query_storage(
&self,
from: Block::Hash,
to: Option<Block::Hash>,
@@ -337,16 +333,16 @@ where
call_fn()
}
- async fn query_storage_at(
+ fn query_storage_at(
&self,
keys: Vec<StorageKey>,
at: Option<Block::Hash>,
) -> std::result::Result<Vec<StorageChangeSet<Block::Hash>>, Error> {
let at = at.unwrap_or_else(|| self.client.info().best_hash);
- self.query_storage(at, Some(at), keys).await
+ self.query_storage(at, Some(at), keys)
}
- async fn read_proof(
+ fn read_proof(
&self,
block: Option<Block::Hash>,
keys: Vec<StorageKey>,
@@ -454,7 +450,7 @@ where
self.executor.spawn("substrate-rpc-subscription", Some("rpc"), fut.boxed());
}
- async fn trace_block(
+ fn trace_block(
&self,
block: Block::Hash,
targets: Option<String>,
@@ -474,7 +470,6 @@ where
}
}
-#[async_trait]
impl<BE, Block, Client> ChildStateBackend<Block, Client> for FullState<BE, Block, Client>
where
Block: BlockT + 'static,
@@ -493,7 +488,7 @@ where
+ 'static,
Client::Api: Metadata<Block>,
{
- async fn read_child_proof(
+ fn read_child_proof(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
@@ -518,7 +513,7 @@ where
.map_err(client_err)
}
- async fn storage_keys(
+ fn storage_keys(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
@@ -536,7 +531,7 @@ where
.map_err(client_err)
}
- async fn storage_keys_paged(
+ fn storage_keys_paged(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
@@ -562,7 +557,7 @@ where
.map_err(client_err)
}
- async fn storage(
+ fn storage(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
@@ -580,7 +575,7 @@ where
.map_err(client_err)
}
- async fn storage_entries(
+ fn storage_entries(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
@@ -595,18 +590,18 @@ where
};
let block = self.block_or_best(block).map_err(client_err)?;
let client = self.client.clone();
- future::try_join_all(keys.into_iter().map(move |key| {
- let res = client
- .clone()
- .child_storage(&BlockId::Hash(block), &child_info, &key)
- .map_err(client_err);
-
- async move { res }
- }))
- .await
+
+ keys.into_iter()
+ .map(move |key| {
+ client
+ .clone()
+ .child_storage(&BlockId::Hash(block), &child_info, &key)
+ .map_err(client_err)
+ })
+ .collect()
}
- async fn storage_hash(
+ fn storage_hash(
&self,
block: Option<Block::Hash>,
storage_key: PrefixedStorageKey,
diff --git a/substrate/client/rpc/src/state/tests.rs b/substrate/client/rpc/src/state/tests.rs
index a375a30d2c1..53dd8ebf504 100644
--- a/substrate/client/rpc/src/state/tests.rs
+++ b/substrate/client/rpc/src/state/tests.rs
@@ -61,31 +61,23 @@ async fn should_return_storage() {
assert_eq!(
client
.storage(key.clone(), Some(genesis_hash).into())
- .await
.map(|x| x.map(|x| x.0.len()))
.unwrap()
.unwrap() as usize,
VALUE.len(),
);
assert_matches!(
- client
- .storage_hash(key.clone(), Some(genesis_hash).into())
- .await
- .map(|x| x.is_some()),
+ client.storage_hash(key.clone(), Some(genesis_hash).into()).map(|x| x.is_some()),
Ok(true)
);
+ assert_eq!(client.storage_size(key.clone(), None).unwrap().unwrap() as usize, VALUE.len(),);
assert_eq!(
- client.storage_size(key.clone(), None).await.unwrap().unwrap() as usize,
- VALUE.len(),
- );
- assert_eq!(
- client.storage_size(StorageKey(b":map".to_vec()), None).await.unwrap().unwrap() as usize,
+ client.storage_size(StorageKey(b":map".to_vec()), None).unwrap().unwrap() as usize,
2 + 3,
);
assert_eq!(
child
.storage(prefixed_storage_key(), key, Some(genesis_hash).into())
- .await
.map(|x| x.map(|x| x.0.len()))
.unwrap()
.unwrap() as usize,
@@ -114,7 +106,6 @@ async fn should_return_storage_entries() {
assert_eq!(
child
.storage_entries(prefixed_storage_key(), keys.to_vec(), Some(genesis_hash).into())
- .await
.map(|x| x.into_iter().map(|x| x.map(|x| x.0.len()).unwrap()).sum::<usize>())
.unwrap(),
CHILD_VALUE1.len() + CHILD_VALUE2.len()
@@ -126,7 +117,6 @@ async fn should_return_storage_entries() {
assert_matches!(
child
.storage_entries(prefixed_storage_key(), failing_keys, Some(genesis_hash).into())
- .await
.map(|x| x.iter().all(|x| x.is_some())),
Ok(false)
);
@@ -150,17 +140,16 @@ async fn should_return_child_storage() {
child_key.clone(),
key.clone(),
Some(genesis_hash).into(),
- ).await,
+ ),
Ok(Some(StorageData(ref d))) if d[0] == 42 && d.len() == 1
);
assert_matches!(
child
.storage_hash(child_key.clone(), key.clone(), Some(genesis_hash).into(),)
- .await
.map(|x| x.is_some()),
Ok(true)
);
- assert_matches!(child.storage_size(child_key.clone(), key.clone(), None).await, Ok(Some(1)));
+ assert_matches!(child.storage_size(child_key.clone(), key.clone(), None), Ok(Some(1)));
}
#[tokio::test]
@@ -179,7 +168,6 @@ async fn should_return_child_storage_entries() {
let res = child
.storage_entries(child_key.clone(), keys.clone(), Some(genesis_hash).into())
- .await
.unwrap();
assert_matches!(
@@ -193,18 +181,12 @@ async fn should_return_child_storage_entries() {
if d[0] == 43 && d[1] == 44 && d.len() == 2
);
assert_matches!(
- executor::block_on(child.storage_hash(
- child_key.clone(),
- keys[0].clone(),
- Some(genesis_hash).into()
- ))
- .map(|x| x.is_some()),
+ child
+ .storage_hash(child_key.clone(), keys[0].clone(), Some(genesis_hash).into())
+ .map(|x| x.is_some()),
Ok(true)
);
- assert_matches!(
- child.storage_size(child_key.clone(), keys[0].clone(), None).await,
- Ok(Some(1))
- );
+ assert_matches!(child.storage_size(child_key.clone(), keys[0].clone(), None), Ok(Some(1)));
}
#[tokio::test]
@@ -216,9 +198,7 @@ async fn should_call_contract() {
use jsonrpsee::{core::Error, types::error::CallError};
assert_matches!(
- client
- .call("balanceOf".into(), Bytes(vec![1, 2, 3]), Some(genesis_hash).into())
- .await,
+ client.call("balanceOf".into(), Bytes(vec![1, 2, 3]), Some(genesis_hash).into()),
Err(Error::Call(CallError::Failed(_)))
)
}
@@ -347,7 +327,7 @@ async fn should_query_storage() {
let keys = (1..6).map(|k| StorageKey(vec![k])).collect::<Vec<_>>();
let result = api.query_storage(keys.clone(), genesis_hash, Some(block1_hash).into());
- assert_eq!(result.await.unwrap(), expected);
+ assert_eq!(result.unwrap(), expected);
// Query all changes
let result = api.query_storage(keys.clone(), genesis_hash, None.into());
@@ -360,18 +340,18 @@ async fn should_query_storage() {
(StorageKey(vec![5]), Some(StorageData(vec![1]))),
],
});
- assert_eq!(result.await.unwrap(), expected);
+ assert_eq!(result.unwrap(), expected);
// Query changes up to block2.
let result = api.query_storage(keys.clone(), genesis_hash, Some(block2_hash));
- assert_eq!(result.await.unwrap(), expected);
+ assert_eq!(result.unwrap(), expected);
// Inverted range.
let result = api.query_storage(keys.clone(), block1_hash, Some(genesis_hash));
assert_eq!(
- result.await.map_err(|e| e.to_string()),
+ result.map_err(|e| e.to_string()),
Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
4001,
Error::InvalidBlockRange {
@@ -392,7 +372,7 @@ async fn should_query_storage() {
let result = api.query_storage(keys.clone(), genesis_hash, Some(random_hash1));
assert_eq!(
- result.await.map_err(|e| e.to_string()),
+ result.map_err(|e| e.to_string()),
Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
4001,
Error::InvalidBlockRange {
@@ -413,7 +393,7 @@ async fn should_query_storage() {
let result = api.query_storage(keys.clone(), random_hash1, Some(genesis_hash));
assert_eq!(
- result.await.map_err(|e| e.to_string()),
+ result.map_err(|e| e.to_string()),
Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
4001,
Error::InvalidBlockRange {
@@ -434,7 +414,7 @@ async fn should_query_storage() {
let result = api.query_storage(keys.clone(), random_hash1, None);
assert_eq!(
- result.await.map_err(|e| e.to_string()),
+ result.map_err(|e| e.to_string()),
Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
4001,
Error::InvalidBlockRange {
@@ -455,7 +435,7 @@ async fn should_query_storage() {
let result = api.query_storage(keys.clone(), random_hash1, Some(random_hash2));
assert_eq!(
- result.await.map_err(|e| e.to_string()),
+ result.map_err(|e| e.to_string()),
Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
4001,
Error::InvalidBlockRange {
@@ -476,7 +456,7 @@ async fn should_query_storage() {
let result = api.query_storage_at(keys.clone(), Some(block1_hash));
assert_eq!(
- result.await.unwrap(),
+ result.unwrap(),
vec![StorageChangeSet {
block: block1_hash,
changes: vec![
@@ -506,7 +486,7 @@ async fn should_return_runtime_version() {
[\"0xf78b278be53f454c\",2],[\"0xab3c0572291feb8b\",1],[\"0xbc9d89904f5b923f\",1]],\
\"transactionVersion\":1,\"stateVersion\":1}";
- let runtime_version = api.runtime_version(None.into()).await.unwrap();
+ let runtime_version = api.runtime_version(None.into()).unwrap();
let serialized = serde_json::to_string(&runtime_version).unwrap();
assert_eq!(serialized, result);
--
GitLab