Merge branch 'tadeohepperle/subxt-metadata-no-std' into tadeohepperle/subxt-core-2

subxt/src/backend/mod.rs

@@ -185,6 +185,7 @@ impl<H: PartialEq> PartialEq for BlockRef<H> {
 }
 impl<H: Eq> Eq for BlockRef<H> {}
 
+// Manual implementation to work around https://github.com/mcarton/rust-derivative/issues/115.
 impl<H: PartialOrd> PartialOrd for BlockRef<H> {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         self.hash.partial_cmp(&other.hash)

subxt/src/backend/rpc/mod.rs

@@ -60,9 +60,13 @@ crate::macros::cfg_jsonrpsee! {
     mod jsonrpsee_impl;
 }
 
+crate::macros::cfg_reconnecting_rpc_client! {
+    mod reconnecting_jsonrpsee_impl;
+    pub use reconnecting_jsonrpsee_ws_client as reconnecting_rpc_client;
+}
+
 mod rpc_client;
 mod rpc_client_t;
 
-pub use rpc_client_t::{RawRpcFuture, RawRpcSubscription, RawValue, RpcClientT};
-
 pub use rpc_client::{rpc_params, RpcClient, RpcParams, RpcSubscription};
+pub use rpc_client_t::{RawRpcFuture, RawRpcSubscription, RawValue, RpcClientT};

subxt/src/backend/rpc/reconnecting_jsonrpsee_impl.rs

@@ -0,0 +1,52 @@
+// 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::{FutureExt, StreamExt, TryStreamExt};
+use reconnecting_jsonrpsee_ws_client::SubscriptionId;
+use serde_json::value::RawValue;
+
+impl RpcClientT for reconnecting_jsonrpsee_ws_client::Client {
+    fn request_raw<'a>(
+        &'a self,
+        method: &'a str,
+        params: Option<Box<RawValue>>,
+    ) -> RawRpcFuture<'a, Box<RawValue>> {
+        async {
+            self.request_raw(method.to_string(), params)
+                .await
+                .map_err(|e| RpcError::ClientError(Box::new(e)))
+        }
+        .boxed()
+    }
+
+    fn subscribe_raw<'a>(
+        &'a self,
+        sub: &'a str,
+        params: Option<Box<RawValue>>,
+        unsub: &'a str,
+    ) -> RawRpcFuture<'a, RawRpcSubscription> {
+        async {
+            let sub = self
+                .subscribe_raw(sub.to_string(), params, unsub.to_string())
+                .await
+                .map_err(|e| RpcError::ClientError(Box::new(e)))?;
+
+            let id = match sub.id() {
+                SubscriptionId::Num(n) => n.to_string(),
+                SubscriptionId::Str(s) => s.to_string(),
+            };
+            let stream = sub
+                .map_err(|e| RpcError::DisconnectedWillReconnect(e.to_string()))
+                .boxed();
+
+            Ok(RawRpcSubscription {
+                stream,
+                id: Some(id),
+            })
+        }
+        .boxed()
+    }
+}

subxt/src/custom_values/custom_value_address.rs

@@ -37,13 +37,25 @@ pub struct Yes;
 
 /// A static address to a custom value.
 #[derive(Derivative)]
-#[derivative(Clone(bound = ""), Debug(bound = ""))]
+#[derivative(
+    Clone(bound = ""),
+    Debug(bound = ""),
+    Eq(bound = ""),
+    Ord(bound = ""),
+    PartialEq(bound = "")
+)]
 pub struct StaticAddress<ReturnTy, IsDecodable> {
     name: &'static str,
     hash: Option<[u8; 32]>,
     phantom: PhantomData<(ReturnTy, IsDecodable)>,
 }
 
+impl<ReturnTy, IsDecodable> PartialOrd for StaticAddress<ReturnTy, IsDecodable> {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
 impl<ReturnTy, IsDecodable> StaticAddress<ReturnTy, IsDecodable> {
     #[doc(hidden)]
     /// Creates a new StaticAddress.

subxt/src/error/mod.rs

@@ -6,8 +6,6 @@
 
 mod dispatch_error;
 
-use core::fmt::Debug;
-
 crate::macros::cfg_unstable_light_client! {
     pub use crate::client::LightClientError;
 }
@@ -113,6 +111,13 @@ impl From<std::convert::Infallible> for Error {
     }
 }
 
+impl Error {
+    /// Checks whether the error was caused by a RPC re-connection.
+    pub fn is_disconnected_will_reconnect(&self) -> bool {
+        matches!(self, Error::Rpc(RpcError::DisconnectedWillReconnect(_)))
+    }
+}
+
 /// An RPC error. Since we are generic over the RPC client that is used,
 /// the error is boxed and could be casted.
 #[derive(Debug, thiserror::Error)]
@@ -133,6 +138,9 @@ pub enum RpcError {
     /// The requested URL is insecure.
     #[error("RPC error: insecure URL: {0}")]
     InsecureUrl(String),
+    /// The connection was lost and automatically reconnected.
+    #[error("RPC error: the connection was lost `{0}`; reconnect automatically initiated")]
+    DisconnectedWillReconnect(String),
 }
 
 impl RpcError {

subxt/src/macros.rs

@@ -52,7 +52,21 @@ macro_rules! cfg_jsonrpsee_web {
 	}
 }
 
-pub(crate) use {cfg_feature, cfg_jsonrpsee, cfg_unstable_light_client};
+#[allow(unused)]
+macro_rules! cfg_reconnecting_rpc_client {
+	($($item:item)*) => {
+		$(
+			#[cfg(all(feature = "unstable-reconnecting-rpc-client"))]
+			#[cfg_attr(docsrs, doc(cfg(feature = "unstable-reconnecting-rpc-client")))]
+			$item
+		)*
+	}
+}
+
+pub(crate) use {
+    cfg_feature, cfg_jsonrpsee, cfg_reconnecting_rpc_client, cfg_substrate_compat,
+    cfg_unstable_light_client,
+};
 
 // Only used by light-client.
 #[allow(unused)]