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/storage/storage_client.rs

@@ -6,8 +6,8 @@ use super::{
     storage_type::{validate_storage_address, Storage},
     utils, StorageAddress,
 };
-
 use crate::{
+    backend::BlockRef,
     client::{OfflineClientT, OnlineClientT},
     error::Error,
     Config,
@@ -73,8 +73,8 @@ where
     Client: OnlineClientT<T>,
 {
     /// Obtain storage at some block hash.
-    pub fn at(&self, block_hash: T::Hash) -> Storage<T, Client> {
-        Storage::new(self.client.clone(), block_hash)
+    pub fn at(&self, block_ref: impl Into<BlockRef<T::Hash>>) -> Storage<T, Client> {
+        Storage::new(self.client.clone(), block_ref.into())
     }
 
     /// Obtain storage at the latest block hash.
@@ -85,14 +85,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(Storage::new(client, block_hash))
+            Ok(Storage::new(client, block_ref))
         }
     }
 }