Introduce Backend trait to allow different RPC (or other) backends to be implemented (#1126)

* WIP backend trait

* WIP converting higher level stuff to using Backend impl

* more implementing new backend trait, mainly storage focused

* Get core code compiling with new backend bits

* subxt crate checks passing

* fix tests

* cargo fmt

* clippy/fixes

* merging and other fixes

* fix test

* fix lightclient code

* Fix some broken doc links

* another book link fix

* fix broken test when moving default_rpc_client

* fix dry_run test

* fix more tests; lightclient and wasm

* fix wasm tests

* fix some doc examples

* use next() instead of next_item()

* missing next_item() -> next()s

* move legacy RPc methods to LegacyRpcMethods type to host generic param instead of RpcClient

* standardise on all RpcClient types prefixed with Rpc, and 'raw' trait types prefixed with RawRpc so it's less ocnfusing which is which

* rename fixes

* doc fixes

* Add back system_dryRun RPC method and rename tx.dry_run() to tx.validate(), to signal that the calls are different

* Add a test that we return the correct extrinsic hash from submit()

* add TransactionValid details back, and protect against out of range bytes

* add test for decoding transaction validation from empty bytes

* fix clippy warning

subxt/src/runtime_api/runtime_client.rs

@@ -4,7 +4,7 @@
 
 use super::runtime_types::RuntimeApi;
 
-use crate::{client::OnlineClientT, error::Error, Config};
+use crate::{backend::BlockRef, client::OnlineClientT, error::Error, Config};
 use derivative::Derivative;
 use std::{future::Future, marker::PhantomData};
 
@@ -32,8 +32,8 @@ where
     Client: OnlineClientT<T>,
 {
     /// Obtain a runtime API interface at some block hash.
-    pub fn at(&self, block_hash: T::Hash) -> RuntimeApi<T, Client> {
-        RuntimeApi::new(self.client.clone(), block_hash)
+    pub fn at(&self, block_ref: impl Into<BlockRef<T::Hash>>) -> RuntimeApi<T, Client> {
+        RuntimeApi::new(self.client.clone(), block_ref.into())
     }
 
     /// Obtain a runtime API interface at the latest block hash.
@@ -44,14 +44,10 @@ where
         // return a Future that's Send + 'static, rather than tied to &self.
         let client = self.client.clone();
         async move {
-            // get the hash for the latest block and use that.
-            let block_hash = client
-                .rpc()
-                .block_hash(None)
-                .await?
-                .expect("didn't pass a block number; qed");
+            // get the ref for the latest block and use that.
+            let block_ref = client.backend().latest_best_block_ref().await?;
 
-            Ok(RuntimeApi::new(client, block_hash))
+            Ok(RuntimeApi::new(client, block_ref))
         }
     }
 }

subxt/src/runtime_api/runtime_types.rs

@@ -3,6 +3,7 @@
 // see LICENSE for license details.
 
 use crate::{
+    backend::{BackendExt, BlockRef},
     client::OnlineClientT,
     error::{Error, MetadataError},
     metadata::DecodeWithMetadata,
@@ -19,16 +20,16 @@ use super::RuntimeApiPayload;
 #[derivative(Clone(bound = "Client: Clone"))]
 pub struct RuntimeApi<T: Config, Client> {
     client: Client,
-    block_hash: T::Hash,
+    block_ref: BlockRef<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 {
+    pub(crate) fn new(client: Client, block_ref: BlockRef<T::Hash>) -> Self {
         Self {
             client,
-            block_hash,
+            block_ref,
             _marker: PhantomData,
         }
     }
@@ -46,13 +47,13 @@ where
         call_parameters: Option<&'a [u8]>,
     ) -> impl Future<Output = Result<Res, Error>> + 'a {
         let client = self.client.clone();
-        let block_hash = self.block_hash;
+        let block_hash = self.block_ref.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: Res = client
-                .rpc()
-                .state_call(function, call_parameters, Some(block_hash))
+                .backend()
+                .call_decoding(function, call_parameters, block_hash)
                 .await?;
             Ok(data)
         }
@@ -64,7 +65,7 @@ where
         payload: Call,
     ) -> impl Future<Output = Result<Call::ReturnType, Error>> {
         let client = self.client.clone();
-        let block_hash = self.block_hash;
+        let block_hash = self.block_ref.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 {
@@ -94,8 +95,8 @@ where
             let call_name = format!("{}_{}", payload.trait_name(), payload.method_name());
 
             let bytes = client
-                .rpc()
-                .state_call_raw(&call_name, Some(params.as_slice()), Some(block_hash))
+                .backend()
+                .call(&call_name, Some(params.as_slice()), block_hash)
                 .await?;
 
             let value = <Call::ReturnType as DecodeWithMetadata>::decode_with_metadata(