Typed chain state queries over rpc.

Cargo.toml

@@ -54,6 +54,7 @@ members = [
 	"core/utils/wasm-builder-runner",
 	"core/wasm-interface",
 	"srml/support",
+	"srml/support/rpc",
 	"srml/support/procedural",
 	"srml/support/procedural/tools",
 	"srml/support/procedural/tools/derive",
@@ -109,4 +110,3 @@ members = [
 [profile.release]
 # Substrate runtime requires unwinding.
 panic = "unwind"
-

srml/support/rpc/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "srml-support-rpc"
+version = "0.1.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"
+srml-support = { path = "../" }
+substrate-primitives-storage = { path = "../../../core/primitives/storage" }
+substrate-rpc-api = { path = "../../../core/rpc/api" }
+
+[dev-dependencies]
+tokio = "0.1"

srml/support/rpc/src/lib.rs

@@ -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 [substrate_rpc_api::state::StateClient] with [srml_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 srml_support::storage::generator::{
+	StorageDoubleMap, StorageLinkedMap, StorageMap, StorageValue
+};
+use substrate_primitives_storage::{StorageData, StorageKey};
+use substrate_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 srml_support::{decl_storage, decl_module};
+/// # use srml_system::Trait;
+/// # use substrate_rpc_api::state::StateClient;
+/// # use substrate_rpc_custom::StorageQuery;
+/// #
+/// # // Hash would normally be <TestRuntime as srml_system::Trait>::Hash, but we don't have
+/// # // srml_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 srml::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()))
+	}
+}

srml/support/src/lib.rs

@@ -262,16 +262,21 @@ mod tests {
 
 	decl_storage! {
 		trait Store for Module<T: Trait> as Example {
-			pub Data get(fn data) build(|_| vec![(15u32, 42u64)]): linked_map hasher(twox_64_concat) u32 => u64;
+			pub Data get(fn data) build(|_| vec![(15u32, 42u64)]):
+				linked_map hasher(twox_64_concat) u32 => u64;
 			pub OptionLinkedMap: linked_map u32 => Option<u32>;
-			pub GenericData get(fn generic_data): linked_map hasher(twox_128) T::BlockNumber => T::BlockNumber;
-			pub GenericData2 get(fn generic_data2): linked_map T::BlockNumber => Option<T::BlockNumber>;
+			pub GenericData get(fn generic_data):
+				linked_map hasher(twox_128) T::BlockNumber => T::BlockNumber;
+			pub GenericData2 get(fn generic_data2):
+				linked_map T::BlockNumber => Option<T::BlockNumber>;
 			pub GetterNoFnKeyword get(no_fn): Option<u32>;
 
 			pub DataDM config(test_config) build(|_| vec![(15u32, 16u32, 42u64)]):
 				double_map hasher(twox_64_concat) u32, blake2_256(u32) => u64;
-			pub GenericDataDM: double_map T::BlockNumber, twox_128(T::BlockNumber) => T::BlockNumber;
-			pub GenericData2DM: double_map T::BlockNumber, twox_256(T::BlockNumber) => Option<T::BlockNumber>;
+			pub GenericDataDM:
+				double_map T::BlockNumber, twox_128(T::BlockNumber) => T::BlockNumber;
+			pub GenericData2DM:
+				double_map T::BlockNumber, twox_256(T::BlockNumber) => Option<T::BlockNumber>;
 			pub AppendableDM: double_map u32, blake2_256(T::BlockNumber) => Vec<u32>;
 		}
 	}