feature: ProviderCall

crates/contract/src/call.rs

@@ -441,7 +441,7 @@ impl<T: Transport + Clone, P: Provider<T, N>, D: CallDecoder, N: Network> CallBu
     /// If this is not desired, use [`call_raw`](Self::call_raw) to get the raw output data.
     #[doc(alias = "eth_call")]
     #[doc(alias = "call_with_overrides")]
-    pub fn call(&self) -> EthCall<'_, '_, '_, D, T, N> {
+    pub fn call(&self) -> EthCall<'_, '_, D, T, N> {
         self.call_raw().with_decoder(&self.decoder)
     }
 
@@ -451,7 +451,7 @@ impl<T: Transport + Clone, P: Provider<T, N>, D: CallDecoder, N: Network> CallBu
     /// Does not decode the output of the call, returning the raw output data instead.
     ///
     /// See [`call`](Self::call) for more information.
-    pub fn call_raw(&self) -> EthCall<'_, '_, '_, (), T, N> {
+    pub fn call_raw(&self) -> EthCall<'_, '_, (), T, N> {
         let call = self.provider.call(&self.request).block(self.block);
         let call = match &self.state {
             Some(state) => call.overrides(state),

crates/contract/src/eth_call.rs

@@ -24,44 +24,44 @@ mod private {
 /// An [`alloy_provider::EthCall`] with an abi decoder.
 #[must_use = "EthCall must be awaited to execute the call"]
 #[derive(Clone, Debug)]
-pub struct EthCall<'req, 'state, 'coder, D, T, N>
+pub struct EthCall<'req, 'coder, D, T, N>
 where
     T: Transport + Clone,
     N: Network,
     D: CallDecoder,
 {
-    inner: alloy_provider::EthCall<'req, 'state, T, N, Bytes>,
+    inner: alloy_provider::EthCall<'req, T, N, Bytes>,
 
     decoder: &'coder D,
 }
 
-impl<'req, 'state, 'coder, D, T, N> EthCall<'req, 'state, 'coder, D, T, N>
+impl<'req, 'coder, D, T, N> EthCall<'req, 'coder, D, T, N>
 where
     T: Transport + Clone,
     N: Network,
     D: CallDecoder,
 {
     /// Create a new [`EthCall`].
     pub const fn new(
-        inner: alloy_provider::EthCall<'req, 'state, T, N, Bytes>,
+        inner: alloy_provider::EthCall<'req, T, N, Bytes>,
         decoder: &'coder D,
     ) -> Self {
         Self { inner, decoder }
     }
 }
 
-impl<'req, 'state, T, N> EthCall<'req, 'state, 'static, (), T, N>
+impl<'req, T, N> EthCall<'req, 'static, (), T, N>
 where
     T: Transport + Clone,
     N: Network,
 {
     /// Create a new [`EthCall`].
-    pub const fn new_raw(inner: alloy_provider::EthCall<'req, 'state, T, N, Bytes>) -> Self {
+    pub const fn new_raw(inner: alloy_provider::EthCall<'req, T, N, Bytes>) -> Self {
         Self::new(inner, &RAW_CODER)
     }
 }
 
-impl<'req, 'state, 'coder, D, T, N> EthCall<'req, 'state, 'coder, D, T, N>
+impl<'req, 'coder, D, T, N> EthCall<'req, 'coder, D, T, N>
 where
     T: Transport + Clone,
     N: Network,
@@ -71,15 +71,15 @@ where
     pub fn with_decoder<'new_coder, E>(
         self,
         decoder: &'new_coder E,
-    ) -> EthCall<'req, 'state, 'new_coder, E, T, N>
+    ) -> EthCall<'req, 'new_coder, E, T, N>
     where
         E: CallDecoder,
     {
         EthCall { inner: self.inner, decoder }
     }
 
     /// Set the state overrides for this call.
-    pub fn overrides(mut self, overrides: &'state StateOverride) -> Self {
+    pub fn overrides(mut self, overrides: &'req StateOverride) -> Self {
         self.inner = self.inner.overrides(overrides);
         self
     }
@@ -91,27 +91,26 @@ where
     }
 }
 
-impl<'req, 'state, T, N> From<alloy_provider::EthCall<'req, 'state, T, N, Bytes>>
-    for EthCall<'req, 'state, 'static, (), T, N>
+impl<'req, T, N> From<alloy_provider::EthCall<'req, T, N, Bytes>>
+    for EthCall<'req, 'static, (), T, N>
 where
     T: Transport + Clone,
     N: Network,
 {
-    fn from(inner: alloy_provider::EthCall<'req, 'state, T, N, Bytes>) -> Self {
+    fn from(inner: alloy_provider::EthCall<'req, T, N, Bytes>) -> Self {
         Self { inner, decoder: &RAW_CODER }
     }
 }
 
-impl<'req, 'state, 'coder, D, T, N> std::future::IntoFuture
-    for EthCall<'req, 'state, 'coder, D, T, N>
+impl<'req, 'coder, D, T, N> std::future::IntoFuture for EthCall<'req, 'coder, D, T, N>
 where
     D: CallDecoder + Unpin,
     T: Transport + Clone,
     N: Network,
 {
     type Output = Result<D::CallOutput>;
 
-    type IntoFuture = EthCallFut<'req, 'state, 'coder, D, T, N>;
+    type IntoFuture = EthCallFut<'req, 'coder, D, T, N>;
 
     fn into_future(self) -> Self::IntoFuture {
         EthCallFut { inner: self.inner.into_future(), decoder: self.decoder }
@@ -121,20 +120,19 @@ where
 /// Future for the [`EthCall`] type. This future wraps an RPC call with an abi
 /// decoder.
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 #[allow(unnameable_types)]
-pub struct EthCallFut<'req, 'state, 'coder, D, T, N>
+pub struct EthCallFut<'req, 'coder, D, T, N>
 where
     T: Transport + Clone,
     N: Network,
     D: CallDecoder,
 {
-    inner: <alloy_provider::EthCall<'req, 'state, T, N, Bytes> as IntoFuture>::IntoFuture,
+    inner: <alloy_provider::EthCall<'req, T, N, Bytes> as IntoFuture>::IntoFuture,
     decoder: &'coder D,
 }
 
-impl<'req, 'state, 'coder, D, T, N> std::future::Future
-    for EthCallFut<'req, 'state, 'coder, D, T, N>
+impl<'req, 'coder, D, T, N> std::future::Future for EthCallFut<'req, 'coder, D, T, N>
 where
     D: CallDecoder + Unpin,
     T: Transport + Clone,

crates/json-rpc/src/request.rs

@@ -78,6 +78,14 @@ impl<Params> Request<Params> {
     pub fn set_subscription_status(&mut self, sub: bool) {
         self.meta.set_subscription_status(sub);
     }
+
+    /// Change type of the request parameters.
+    pub fn map_params<NewParams>(
+        self,
+        map: impl FnOnce(Params) -> NewParams,
+    ) -> Request<NewParams> {
+        Request { meta: self.meta, params: map(self.params) }
+    }
 }
 
 /// A [`Request`] that has been partially serialized. The request parameters
@@ -112,11 +120,12 @@ where
 
 impl<Params> Request<&Params>
 where
-    Params: Clone,
+    Params: ToOwned,
+    Params::Owned: RpcParam,
 {
     /// Clone the request, including the request parameters.
-    pub fn into_owned_params(self) -> Request<Params> {
-        Request { meta: self.meta, params: self.params.clone() }
+    pub fn into_owned_params(self) -> Request<Params::Owned> {
+        Request { meta: self.meta, params: self.params.to_owned() }
     }
 }
 

crates/provider/src/ext/trace.rs

@@ -112,14 +112,14 @@ where
         trace_types: &'b [TraceType],
     ) -> RpcWithBlock<T, (&'a <N as Network>::TransactionRequest, &'b [TraceType]), TraceResults>
     {
-        RpcWithBlock::new(self.weak_client(), "trace_call", (request, trace_types))
+        self.client().request("trace_call", (request, trace_types)).into()
     }
 
     fn trace_call_many<'a>(
         &self,
         request: TraceCallList<'a, N>,
     ) -> RpcWithBlock<T, TraceCallList<'a, N>, TraceResults> {
-        RpcWithBlock::new(self.weak_client(), "trace_callMany", request)
+        self.client().request("trace_callMany", request).into()
     }
 
     async fn trace_transaction(

crates/provider/src/lib.rs

@@ -28,23 +28,24 @@ extern crate tracing;
 mod builder;
 pub use builder::{Identity, ProviderBuilder, ProviderLayer, Stack};
 
+mod chain;
+
 pub mod ext;
 
 pub mod fillers;
-pub mod layers;
-
-mod chain;
 
 mod heart;
 pub use heart::{
     PendingTransaction, PendingTransactionBuilder, PendingTransactionConfig,
     PendingTransactionError, WatchTxError,
 };
 
+pub mod layers;
+
 mod provider;
 pub use provider::{
-    builder, EthCall, FilterPollerBuilder, Provider, RootProvider, RpcWithBlock, SendableTx,
-    WalletProvider,
+    builder, Caller, EthCall, EthCallParams, FilterPollerBuilder, ParamsWithBlock, Provider,
+    ProviderCall, RootProvider, RpcWithBlock, SendableTx, WalletProvider,
 };
 
 pub mod utils;

crates/provider/src/provider/caller.rs

@@ -0,0 +1,42 @@
+use crate::ProviderCall;
+use alloy_json_rpc::{RpcParam, RpcReturn};
+use alloy_rpc_client::WeakClient;
+use alloy_transport::{RpcError, Transport, TransportErrorKind, TransportResult};
+use std::borrow::Cow;
+
+/// A caller that helper convert `RpcWithBlock` and `EthCall` into a `ProviderCall`.
+pub trait Caller<T, Params, Resp>: Send + Sync
+where
+    T: Transport + Clone,
+    Params: RpcParam,
+    Resp: RpcReturn,
+{
+    /// Methods that needs to be implemented to convert to a `ProviderCall`.
+    fn call(
+        &self,
+        method: Cow<'static, str>,
+        params: Params,
+    ) -> TransportResult<ProviderCall<T, serde_json::Value, Resp>>;
+}
+
+impl<T, Params, Resp> Caller<T, Params, Resp> for WeakClient<T>
+where
+    T: Transport + Clone,
+    Params: RpcParam,
+    Resp: RpcReturn,
+{
+    fn call(
+        &self,
+        method: Cow<'static, str>,
+        params: Params,
+    ) -> TransportResult<ProviderCall<T, serde_json::Value, Resp>> {
+        let client = self.upgrade().ok_or_else(TransportErrorKind::backend_gone)?;
+
+        // serialize the params
+        let ser = serde_json::to_value(params).map_err(RpcError::ser_err)?;
+
+        let rpc_call = client.request(method, ser);
+
+        Ok(ProviderCall::RpcCall(rpc_call))
+    }
+}