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

testing/integration-tests/src/utils/node_proc.rs

@@ -4,7 +4,10 @@
 
 use std::ffi::{OsStr, OsString};
 use substrate_runner::SubstrateNode;
-use subxt::{Config, OnlineClient};
+use subxt::{
+    backend::{legacy, rpc},
+    Config, OnlineClient,
+};
 
 #[cfg(feature = "unstable-light-client")]
 use subxt::client::{LightClient, LightClientBuilder};
@@ -12,7 +15,7 @@ use subxt::client::{LightClient, LightClientBuilder};
 /// Spawn a local substrate node for testing subxt.
 pub struct TestNodeProcess<R: Config> {
     // Keep a handle to the node; once it's dropped the node is killed.
-    _proc: SubstrateNode,
+    proc: SubstrateNode,
 
     #[cfg(not(feature = "unstable-light-client"))]
     client: OnlineClient<R>,
@@ -33,6 +36,15 @@ where
         TestNodeProcessBuilder::new(paths)
     }
 
+    /// Hand back an RPC client connected to the test node.
+    pub async fn legacy_rpc_methods(&self) -> legacy::LegacyRpcMethods<R> {
+        let url = format!("ws://127.0.0.1:{}", self.proc.ws_port());
+        let rpc_client = rpc::RpcClient::from_url(url)
+            .await
+            .expect("Unable to connect RPC client to test node");
+        legacy::LegacyRpcMethods::new(rpc_client)
+    }
+
     /// Returns the subxt client connected to the running node.
     #[cfg(not(feature = "unstable-light-client"))]
     pub fn client(&self) -> OnlineClient<R> {
@@ -101,10 +113,7 @@ impl TestNodeProcessBuilder {
         let client = OnlineClient::from_url(ws_url.clone()).await;
 
         match client {
-            Ok(client) => Ok(TestNodeProcess {
-                _proc: proc,
-                client,
-            }),
+            Ok(client) => Ok(TestNodeProcess { proc, client }),
             Err(err) => Err(format!("Failed to connect to node rpc at {ws_url}: {err}")),
         }
     }

testing/integration-tests/src/utils/wait_for_blocks.rs

@@ -6,14 +6,14 @@ use subxt::{client::OnlineClientT, Config};
 
 /// Wait for blocks to be produced before running tests. Waiting for two blocks
 /// (the genesis block and another one) seems to be enough to allow tests
-/// like `dry_run_passes` to work properly.
+/// like `validation_passes` to work properly.
 ///
 /// If the "unstable-light-client" feature flag is enabled, this will wait for
 /// 5 blocks instead of two. The light client needs the extra blocks to avoid
 /// errors caused by loading information that is not available in the first 2 blocks
 /// (`Failed to load the block weight for block`).
 pub async fn wait_for_blocks<C: Config>(api: &impl OnlineClientT<C>) {
-    let mut sub = api.rpc().subscribe_all_block_headers().await.unwrap();
+    let mut sub = api.backend().stream_all_block_headers().await.unwrap();
     sub.next().await;
     sub.next().await;