Split RPCs into a separate crate (#1910)

* WIP extract RPCs into separate crate * fmt * Fix test * Remove unused deps * fix import * WIP: Fix up errors and most tests. Start extracintg some tests/code to rpc crate * MockRpcClient sync or async * MockRpcClient only async but better type inference * WIP MockRpcClient FnMuts and some test updates to use it * Get all but one test working with new MockRpcClient * WIP trying to debug failure * WIP, Tests mostly fixed, need to add back oen more * Get mock RPC tests working * fmt * fmt * Clippy and comment tweak * update CI to explicitly check subxt-rpc features * clippy * small tweaks after pass over * feature flag rename * update some docs * Fix some examples * fmt * Fix features flags to work with web/wasm32 * Fix unused dep warning * explicit targets in wasm CI * Add better crate level docs * fmt * Address review comments * Comment out flaky test for now and make more obvious how similar POlkadot and Substrate configs are * Not a doc comment * Remove unused imports
2026-07-25 02:25:51 +00:00 · 2025-02-18 12:07:00 +00:00
parent 333de953ec
commit 816a86423b
50 changed files with 4575 additions and 1186 deletions
@@ -0,0 +1,84 @@
+// Copyright 2019-2025 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;
+use futures::stream::{StreamExt, TryStreamExt};
+use jsonrpsee::{
+    core::{
+        client::{Error as JsonrpseeError, Client, ClientT, SubscriptionClientT, SubscriptionKind},
+        traits::ToRpcParams,
+    },
+    types::SubscriptionId,
+};
+use serde_json::value::RawValue;
+
+struct Params(Option<Box<RawValue>>);
+
+impl ToRpcParams for Params {
+    fn to_rpc_params(self) -> Result<Option<Box<RawValue>>, serde_json::Error> {
+        Ok(self.0)
+    }
+}
+
+impl RpcClientT for Client {
+    fn request_raw<'a>(
+        &'a self,
+        method: &'a str,
+        params: Option<Box<RawValue>>,
+    ) -> RawRpcFuture<'a, Box<RawValue>> {
+        Box::pin(async move {
+            let res = ClientT::request(self, method, Params(params)).await?;
+            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 stream = SubscriptionClientT::subscribe::<Box<RawValue>, _>(
+                self,
+                sub,
+                Params(params),
+                unsub,
+            ).await?;
+
+            let id = match stream.kind() {
+                SubscriptionKind::Subscription(SubscriptionId::Str(id)) => {
+                    Some(id.clone().into_owned())
+                }
+                _ => None,
+            };
+
+            let stream = stream
+                .map_err(|e| Error::Client(Box::new(e)))
+                .boxed();
+            Ok(RawRpcSubscription { stream, id })
+        })
+    }
+}
+
+// Convert a JsonrpseeError into the RPC error in this crate.
+// The main reason for this is to capture user errors so that
+// they can be represented/handled without casting. 
+impl From<JsonrpseeError> for Error {
+    fn from(error: JsonrpseeError) -> Self {
+        match error {
+            JsonrpseeError::Call(e) => {
+                Error::User(crate::UserError {
+                    code: e.code(),
+                    message: e.message().to_owned(),
+                    data: e.data().map(|d| d.to_owned())
+                })
+            },
+            e => {
+                Error::Client(Box::new(e))
+            }
+        }
+    }
+}