Add Runtime API to execute runtime calls (#777)

* rpc: Add RuntimeAPI call via `state_call` method

Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>

* subxt: Add runtime API

Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>

* Expose the RuntimeAPI client

Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>

* tests: Test the runtime API call against the metadata

Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>

* client: Fetch the metadata from runtime API

Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>

* blocks: Fix doc typo

Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>

* blocks: Use &str instead of String to identify fn names

Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>

* Update subxt/src/runtime_api/runtime_client.rs

Co-authored-by: Niklas Adolfsson <niklasadolfsson1@gmail.com>

Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
Co-authored-by: Niklas Adolfsson <niklasadolfsson1@gmail.com>

subxt/src/runtime_api/mod.rs

@@ -0,0 +1,11 @@
+// Copyright 2019-2022 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+//! Types associated with executing runtime API calls.
+
+mod runtime_client;
+mod runtime_types;
+
+pub use runtime_client::RuntimeApiClient;
+pub use runtime_types::RuntimeApi;

subxt/src/runtime_api/runtime_client.rs

@@ -0,0 +1,66 @@
+// Copyright 2019-2022 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+use super::runtime_types::RuntimeApi;
+
+use crate::{
+    client::OnlineClientT,
+    error::Error,
+    Config,
+};
+use derivative::Derivative;
+use std::{
+    future::Future,
+    marker::PhantomData,
+};
+
+/// Execute runtime API calls.
+#[derive(Derivative)]
+#[derivative(Clone(bound = "Client: Clone"))]
+pub struct RuntimeApiClient<T, Client> {
+    client: Client,
+    _marker: PhantomData<T>,
+}
+
+impl<T, Client> RuntimeApiClient<T, Client> {
+    /// Create a new [`RuntimeApiClient`]
+    pub fn new(client: Client) -> Self {
+        Self {
+            client,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T, Client> RuntimeApiClient<T, Client>
+where
+    T: Config,
+    Client: OnlineClientT<T>,
+{
+    /// Obtain a runtime API at some block hash.
+    pub fn at(
+        &self,
+        block_hash: Option<T::Hash>,
+    ) -> impl Future<Output = Result<RuntimeApi<T, Client>, Error>> + Send + 'static {
+        // Clone and pass the client in like this so that we can explicitly
+        // return a Future that's Send + 'static, rather than tied to &self.
+        let client = self.client.clone();
+        async move {
+            // If block hash is not provided, get the hash
+            // for the latest block and use that.
+            let block_hash = match block_hash {
+                Some(hash) => hash,
+                None => {
+                    client
+                        .rpc()
+                        .block_hash(None)
+                        .await?
+                        .expect("substrate RPC returns the best block when no block number is provided; qed")
+                }
+            };
+
+            Ok(RuntimeApi::new(client, block_hash))
+        }
+    }
+}

subxt/src/runtime_api/runtime_types.rs

@@ -0,0 +1,59 @@
+// Copyright 2019-2022 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+use crate::{
+    client::OnlineClientT,
+    error::Error,
+    Config,
+};
+use derivative::Derivative;
+use std::{
+    future::Future,
+    marker::PhantomData,
+};
+
+/// Execute runtime API calls.
+#[derive(Derivative)]
+#[derivative(Clone(bound = "Client: Clone"))]
+pub struct RuntimeApi<T: Config, Client> {
+    client: Client,
+    block_hash: T::Hash,
+    _marker: PhantomData<T>,
+}
+
+impl<T: Config, Client> RuntimeApi<T, Client> {
+    /// Create a new [`RuntimeApi`]
+    pub(crate) fn new(client: Client, block_hash: T::Hash) -> Self {
+        Self {
+            client,
+            block_hash,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T, Client> RuntimeApi<T, Client>
+where
+    T: Config,
+    Client: OnlineClientT<T>,
+{
+    /// Execute a raw runtime API call.
+    pub fn call_raw<'a>(
+        &self,
+        function: &'a str,
+        call_parameters: Option<&'a [u8]>,
+    ) -> impl Future<Output = Result<Vec<u8>, Error>> + 'a {
+        let client = self.client.clone();
+        let block_hash = self.block_hash;
+        // Ensure that the returned future doesn't have a lifetime tied to api.runtime_api(),
+        // which is a temporary thing we'll be throwing away quickly:
+        async move {
+            let data = client
+                .rpc()
+                .state_call(function, call_parameters, Some(block_hash))
+                .await?;
+            Ok(data.0)
+        }
+    }
+}