feat: convert EthCall to ProviderCall

* use `ClientRef` in EthCall instead of `WeakClient`

* change lifetimes

* add *_internal methods that return `EthCall`

crates/contract/src/call.rs

@@ -419,7 +419,7 @@ impl<T: Transport + Clone, P: Provider<T, N>, D: CallDecoder, N: Network> CallBu
     /// Returns the estimated gas cost for the underlying transaction to be executed
     /// If [`state overrides`](Self::state) are set, they will be applied to the gas estimation.
     pub async fn estimate_gas(&self) -> Result<u128> {
-        let mut estimate = self.provider.estimate_gas(&self.request);
+        let mut estimate = self.provider.estimate_gas_internal(&self.request);
         if let Some(state) = &self.state {
             estimate = estimate.overrides(state);
         }
@@ -444,7 +444,7 @@ impl<T: Transport + Clone, P: Provider<T, N>, D: CallDecoder, N: Network> CallBu
     ///
     /// See [`call`](Self::call) for more information.
     pub fn call_raw(&self) -> EthCall<'_, '_, '_, (), T, N> {
-        let call = self.provider.call(&self.request).block(self.block);
+        let call = self.provider.call_internal(&self.request).block(self.block);
         let call = match &self.state {
             Some(state) => call.overrides(state),
             None => call,

crates/provider/src/lib.rs

@@ -41,8 +41,8 @@ pub mod layers;
 
 mod provider;
 pub use provider::{
-    builder, EthCall, FilterPollerBuilder, Provider, ProviderCall, RootProvider, RpcWithBlock,
-    SendableTx, WalletProvider,
+    builder, EthCall, EthCallParams, FilterPollerBuilder, Provider, ProviderCall, RootProvider,
+    RpcWithBlock, SendableTx, WalletProvider,
 };
 
 pub mod utils;

crates/provider/src/provider/eth_call.rs

@@ -1,9 +1,10 @@
+use crate::ProviderCall;
 use alloy_eips::BlockId;
 use alloy_json_rpc::RpcReturn;
 use alloy_network::Network;
-use alloy_rpc_client::{RpcCall, WeakClient};
+use alloy_rpc_client::{ClientRef, RpcCall};
 use alloy_rpc_types_eth::state::StateOverride;
-use alloy_transport::{Transport, TransportErrorKind, TransportResult};
+use alloy_transport::{Transport, TransportResult};
 use futures::FutureExt;
 use serde::ser::SerializeSeq;
 use std::{future::Future, marker::PhantomData, task::Poll};
@@ -12,7 +13,8 @@ type RunningFut<'req, 'state, T, N, Resp, Output, Map> =
     RpcCall<T, EthCallParams<'req, 'state, N>, Resp, Output, Map>;
 
 #[derive(Clone, Debug)]
-struct EthCallParams<'req, 'state, N: Network> {
+#[doc(hidden)] // Not public API.
+pub struct EthCallParams<'req, 'state, N: Network> {
     data: &'req N::TransactionRequest,
     block: Option<BlockId>,
     overrides: Option<&'state StateOverride>,
@@ -58,7 +60,7 @@ where
     Map: Fn(Resp) -> Output,
 {
     Preparing {
-        client: WeakClient<T>,
+        client: ClientRef<'req, T>,
         data: &'req N::TransactionRequest,
         overrides: Option<&'state StateOverride>,
         block: Option<BlockId>,
@@ -94,11 +96,6 @@ where
             unreachable!("bad state")
         };
 
-        let client = match client.upgrade().ok_or_else(TransportErrorKind::backend_gone) {
-            Ok(client) => client,
-            Err(e) => return Poll::Ready(Err(e)),
-        };
-
         let params = EthCallParams { data, block, overrides };
 
         let fut = client.request(method, params).map_resp(map);
@@ -153,8 +150,7 @@ where
     Resp: RpcReturn,
     Map: Fn(Resp) -> Output,
 {
-    client: WeakClient<T>,
-
+    client: ClientRef<'req, T>,
     data: &'req N::TransactionRequest,
     overrides: Option<&'state StateOverride>,
     block: Option<BlockId>,
@@ -170,7 +166,7 @@ where
     Resp: RpcReturn,
 {
     /// Create a new CallBuilder.
-    pub const fn new(client: WeakClient<T>, data: &'req N::TransactionRequest) -> Self {
+    pub const fn new(client: ClientRef<'req, T>, data: &'req N::TransactionRequest) -> Self {
         Self {
             client,
             data,
@@ -183,7 +179,10 @@ where
     }
 
     /// Create new EthCall for gas estimates.
-    pub const fn gas_estimate(client: WeakClient<T>, data: &'req N::TransactionRequest) -> Self {
+    pub const fn gas_estimate(
+        client: ClientRef<'req, T>,
+        data: &'req N::TransactionRequest,
+    ) -> Self {
         Self {
             client,
             data,
@@ -245,6 +244,25 @@ where
     }
 }
 
+impl<'req, T, N, Resp, Output, Map> EthCall<'req, 'req, T, N, Resp, Output, Map>
+where
+    T: Transport + Clone,
+    N: Network,
+    Resp: RpcReturn,
+    Map: Fn(Resp) -> Output,
+{
+    /// Convert EthCall into a ProviderCall
+    pub(crate) fn into_provider_call(
+        self,
+    ) -> ProviderCall<T, EthCallParams<'req, 'req, N>, Resp, Output, Map> {
+        let EthCall { client, data, overrides, block, method, map, .. } = self;
+        let params = EthCallParams { data, overrides, block };
+
+        let fut = client.request(method, params).map_resp(map);
+        fut.into()
+    }
+}
+
 impl<'req, 'state, T, N, Resp, Output, Map> std::future::IntoFuture
     for EthCall<'req, 'state, T, N, Resp, Output, Map>
 where

crates/provider/src/provider/mod.rs

@@ -1,5 +1,5 @@
 mod eth_call;
-pub use eth_call::EthCall;
+pub use eth_call::{EthCall, EthCallParams};
 
 mod prov_call;
 pub use prov_call::ProviderCall;

crates/provider/src/provider/trait.rs

@@ -2,8 +2,9 @@
 
 use crate::{
     utils::{self, Eip1559Estimation, EstimatorFunction},
-    EthCall, Identity, PendingTransaction, PendingTransactionBuilder, PendingTransactionConfig,
-    ProviderBuilder, ProviderCall, RootProvider, RpcWithBlock, SendableTx,
+    EthCall, EthCallParams, Identity, PendingTransaction, PendingTransactionBuilder,
+    PendingTransactionConfig, ProviderBuilder, ProviderCall, RootProvider, RpcWithBlock,
+    SendableTx,
 };
 use alloy_eips::eip2718::Encodable2718;
 use alloy_json_rpc::{RpcError, RpcParam, RpcReturn};
@@ -150,8 +151,21 @@ pub trait Provider<T: Transport + Clone = BoxTransport, N: Network = Ethereum>:
     /// Not all client implementations support state overrides.
     #[doc(alias = "eth_call")]
     #[doc(alias = "call_with_overrides")]
-    fn call<'req>(&self, tx: &'req N::TransactionRequest) -> EthCall<'req, 'static, T, N, Bytes> {
-        EthCall::new(self.weak_client(), tx)
+    fn call<'req>(
+        &'req self,
+        tx: &'req N::TransactionRequest,
+    ) -> ProviderCall<T, EthCallParams<'req, 'req, N>, Bytes, Bytes> {
+        let call = self.call_internal(tx);
+        call.into_provider_call()
+    }
+
+    /// This method returns `EthCall` struct.
+    /// It is useful when we have to set the block or state overrides after generating the struct.
+    fn call_internal<'req>(
+        &'req self,
+        tx: &'req N::TransactionRequest,
+    ) -> EthCall<'req, 'req, T, N, Bytes, Bytes> {
+        EthCall::new(self.client(), tx)
     }
 
     /// Gets the chain ID.
@@ -183,10 +197,21 @@ pub trait Provider<T: Transport + Clone = BoxTransport, N: Network = Ethereum>:
     ///
     /// Not all client implementations support state overrides for eth_estimateGas.
     fn estimate_gas<'req>(
-        &self,
+        &'req self,
+        tx: &'req N::TransactionRequest,
+    ) -> ProviderCall<T, EthCallParams<'req, 'req, N>, U128, u128> {
+        let call = self.estimate_gas_internal(tx);
+        call.into_provider_call()
+    }
+
+    /// This method returns `EthCall` struct.
+    /// It is useful when we have to set the block or state overrides after generating the struct.
+    fn estimate_gas_internal<'req>(
+        &'req self,
         tx: &'req N::TransactionRequest,
     ) -> EthCall<'req, 'static, T, N, U128, u128> {
-        EthCall::gas_estimate(self.weak_client(), tx).map_resp(crate::utils::convert_u128)
+        EthCall::gas_estimate(self.client(), tx)
+            .map_resp(crate::utils::convert_u128 as fn(U128) -> u128)
     }
 
     /// Estimates the EIP1559 `maxFeePerGas` and `maxPriorityFeePerGas` fields.
@@ -1426,7 +1451,11 @@ mod tests {
         let req = TransactionRequest::default()
             .with_to(address!("c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2")) // WETH
             .with_input(bytes!("06fdde03")); // `name()`
-        let result = provider.call(&req).await.unwrap();
+        let provider_call = provider.call(&req);
+
+        assert!(matches!(provider_call, ProviderCall::RpcCall(_)));
+
+        let result = provider_call.await.unwrap();
         assert_eq!(String::abi_decode(&result, true).unwrap(), "Wrapped Ether");
     }