Rework light client (#1475)

* WIP second pass over light client code for simpler API

* First pass new light client

* pub(crate) LightClientRpc::new_raw(), and fmt

* Update examples and add back a way to configure boot nodes and fetch chainspec from a URL

* Fix light client examples

* remove unused deps and tidy lightclient feature flags

* fix wasm error

* LightClientRpc can be cloned

* update light client tests

* Other small fixes

* exclude mod unless jsonrpsee

* Fix wasm-lightclient-tests

* add back docsrs bit and web+native feature flag compile error

* update book and light client example names

* fix docs

subxt/src/backend/legacy/mod.rs

@@ -53,10 +53,10 @@ impl<T: Config> LegacyBackendBuilder<T> {
 
     /// Given an [`RpcClient`] to use to make requests, this returns a [`LegacyBackend`],
     /// which implements the [`Backend`] trait.
-    pub fn build(self, client: RpcClient) -> LegacyBackend<T> {
+    pub fn build(self, client: impl Into<RpcClient>) -> LegacyBackend<T> {
         LegacyBackend {
             storage_page_size: self.storage_page_size,
-            methods: LegacyRpcMethods::new(client),
+            methods: LegacyRpcMethods::new(client.into()),
         }
     }
 }

subxt/src/backend/rpc/lightclient_impl.rs

@@ -0,0 +1,53 @@
+// Copyright 2019-2023 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+use super::{RawRpcFuture, RawRpcSubscription, RpcClientT};
+use crate::error::RpcError;
+use futures::stream::{StreamExt, TryStreamExt};
+use serde_json::value::RawValue;
+use subxt_lightclient::{LightClientRpc, LightClientRpcError};
+
+impl RpcClientT for LightClientRpc {
+    fn request_raw<'a>(
+        &'a self,
+        method: &'a str,
+        params: Option<Box<RawValue>>,
+    ) -> RawRpcFuture<'a, Box<RawValue>> {
+        Box::pin(async move {
+            let res = self.request(method.to_owned(), params)
+                .await
+                .map_err(lc_err_to_rpc_err)?;
+
+            Ok(res)
+        })
+    }
+
+    fn subscribe_raw<'a>(
+        &'a self,
+        sub: &'a str,
+        params: Option<Box<RawValue>>,
+        unsub: &'a str,
+    ) -> RawRpcFuture<'a, RawRpcSubscription> {
+        Box::pin(async move {
+            let sub = self.subscribe(sub.to_owned(), params, unsub.to_owned())
+                .await
+                .map_err(lc_err_to_rpc_err)?;
+
+            let id = Some(sub.id().to_owned());
+            let stream = sub
+                .map_err(|e| RpcError::ClientError(Box::new(e)))
+                .boxed();
+
+            Ok(RawRpcSubscription { id, stream })
+        })
+    }
+}
+
+fn lc_err_to_rpc_err(err: LightClientRpcError) -> RpcError {
+    match err {
+        LightClientRpcError::JsonRpcError(e) => RpcError::ClientError(Box::new(e)),
+        LightClientRpcError::SmoldotError(e) => RpcError::RequestRejected(e),
+        LightClientRpcError::BackgroundTaskDropped => RpcError::SubscriptionDropped,
+    }
+}

subxt/src/backend/rpc/mod.rs

@@ -60,6 +60,10 @@ crate::macros::cfg_jsonrpsee! {
     mod jsonrpsee_impl;
 }
 
+crate::macros::cfg_unstable_light_client! {
+    mod lightclient_impl;
+}
+
 crate::macros::cfg_reconnecting_rpc_client! {
     mod reconnecting_jsonrpsee_impl;
     pub use reconnecting_jsonrpsee_ws_client as reconnecting_rpc_client;

subxt/src/backend/rpc/rpc_client.rs

@@ -79,6 +79,12 @@ impl RpcClient {
     }
 }
 
+impl<C: RpcClientT> From<C> for RpcClient {
+    fn from(client: C) -> Self {
+        RpcClient::new(client)
+    }
+}
+
 impl std::fmt::Debug for RpcClient {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_tuple("RpcClient").finish()

subxt/src/backend/unstable/mod.rs

@@ -75,9 +75,12 @@ impl<T: Config> UnstableBackendBuilder<T> {
     /// Given an [`RpcClient`] to use to make requests, this returns a tuple of an [`UnstableBackend`],
     /// which implements the [`Backend`] trait, and an [`UnstableBackendDriver`] which must be polled in
     /// order for the backend to make progress.
-    pub fn build(self, client: RpcClient) -> (UnstableBackend<T>, UnstableBackendDriver<T>) {
+    pub fn build(
+        self,
+        client: impl Into<RpcClient>,
+    ) -> (UnstableBackend<T>, UnstableBackendDriver<T>) {
         // Construct the underlying follow_stream layers:
-        let rpc_methods = UnstableRpcMethods::new(client);
+        let rpc_methods = UnstableRpcMethods::new(client.into());
         let follow_stream =
             follow_stream::FollowStream::<T::Hash>::from_methods(rpc_methods.clone());
         let follow_stream_unpin = follow_stream_unpin::FollowStreamUnpin::<T::Hash>::from_methods(