fix: remove the cow

crates/json-rpc/src/request.rs

@@ -62,6 +62,16 @@ where
     }
 }
 
+impl<Params> Request<&Params>
+where
+    Params: Clone,
+{
+    /// Clone the request, including the request parameters.
+    pub fn into_owned_params(self) -> Request<Params> {
+        Request { meta: self.meta, params: self.params.clone() }
+    }
+}
+
 impl<'a, Params> Request<Params>
 where
     Params: AsRef<RawValue> + 'a,

crates/rpc-client/src/call.rs

@@ -175,6 +175,23 @@ where
     }
 }
 
+impl<Conn, Params, Resp> RpcCall<Conn, &Params, Resp>
+where
+    Conn: Transport + Clone,
+    Params: RpcParam + Clone,
+{
+    /// Convert this call into one with owned params, by cloning the params.
+    pub fn into_owned_params(self) -> RpcCall<Conn, Params, Resp> {
+        if let CallState::Prepared { request, connection } = self.state {
+            let request =
+                request.expect("No params in prepared. This is a bug").into_owned_params();
+            RpcCall::new(request, connection)
+        } else {
+            panic!("Cannot get params after request has been sent");
+        }
+    }
+}
+
 impl<'a, Conn, Params, Resp> RpcCall<Conn, Params, Resp>
 where
     Conn: Transport + Clone,

crates/rpc-client/src/client.rs

@@ -2,10 +2,7 @@ use crate::{BatchRequest, ClientBuilder, RpcCall};
 use alloy_json_rpc::{Id, Request, RequestMeta, RpcParam, RpcReturn};
 use alloy_transport::{BoxTransport, Transport, TransportConnect, TransportError};
 use alloy_transport_http::Http;
-use std::{
-    borrow::Cow,
-    sync::atomic::{AtomicU64, Ordering},
-};
+use std::sync::atomic::{AtomicU64, Ordering};
 use tower::{layer::util::Identity, ServiceBuilder};
 
 /// A JSON-RPC client.
@@ -57,11 +54,11 @@ impl<T> RpcClient<T> {
     /// This function reserves an ID for the request, however the request
     /// is not sent. To send a request, use [`RpcClient::prepare`] and await
     /// the returned [`RpcCall`].
-    pub fn make_request<'a, Params: RpcParam>(
+    pub fn make_request<Params: RpcParam>(
         &self,
         method: &'static str,
-        params: Cow<'a, Params>,
-    ) -> Request<Cow<'a, Params>> {
+        params: Params,
+    ) -> Request<Params> {
         Request { meta: RequestMeta { method, id: self.next_id() }, params }
     }
 
@@ -108,11 +105,11 @@ where
     /// Serialization is done lazily. It will not be performed until the call
     /// is awaited. This means that if a serializer error occurs, it will not
     /// be caught until the call is awaited.
-    pub fn prepare<'a, Params: RpcParam, Resp: RpcReturn>(
+    pub fn prepare<Params: RpcParam, Resp: RpcReturn>(
         &self,
         method: &'static str,
-        params: Cow<'a, Params>,
-    ) -> RpcCall<T, Cow<'a, Params>, Resp> {
+        params: Params,
+    ) -> RpcCall<T, Params, Resp> {
         let request = self.make_request(method, params);
         RpcCall::new(request, self.transport.clone())
     }