perf: remove some clones around eth_call (#16665)

Author: hai-rise

crates/rpc/rpc-eth-api/src/helpers/call.rs

@@ -215,7 +215,7 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
         overrides: EvmOverrides,
     ) -> impl Future<Output = Result<Bytes, Self::Error>> + Send {
         async move {
-            let (res, _env) =
+            let res =
                 self.transact_call_at(request, block_number.unwrap_or_default(), overrides).await?;
 
             ensure_success(res.result)
@@ -288,7 +288,7 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
                     let block_transactions = block.transactions_recovered().take(num_txs);
                     for tx in block_transactions {
                         let tx_env = RpcNodeCore::evm_config(&this).tx_env(tx);
-                        let (res, _) = this.transact(&mut db, evm_env.clone(), tx_env)?;
+                        let res = this.transact(&mut db, evm_env.clone(), tx_env)?;
                         db.commit(res.state);
                     }
                 }
@@ -313,7 +313,7 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
 
                         let (current_evm_env, prepared_tx) =
                             this.prepare_call_env(evm_env.clone(), tx, &mut db, overrides)?;
-                        let (res, _) = this.transact(&mut db, current_evm_env, prepared_tx)?;
+                        let res = this.transact(&mut db, current_evm_env, prepared_tx)?;
 
                         match ensure_success::<_, Self::Error>(res.result) {
                             Ok(output) => {
@@ -426,11 +426,11 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA
         };
 
         // transact again to get the exact gas used
-        let (result, (_, tx_env)) = self.transact(&mut db, evm_env, tx_env)?;
+        let gas_limit = tx_env.gas_limit();
+        let result = self.transact(&mut db, evm_env, tx_env)?;
         let res = match result.result {
             ExecutionResult::Halt { reason, gas_used } => {
-                let error =
-                    Some(Self::Error::from_evm_halt(reason, tx_env.gas_limit()).to_string());
+                let error = Some(Self::Error::from_evm_halt(reason, gas_limit).to_string());
                 AccessListResult { access_list, gas_used: U256::from(gas_used), error }
             }
             ExecutionResult::Revert { output, gas_used } => {
@@ -477,61 +477,47 @@ pub trait Call:
 
     /// Executes the `TxEnv` against the given [Database] without committing state
     /// changes.
-    #[expect(clippy::type_complexity)]
     fn transact<DB>(
         &self,
         db: DB,
         evm_env: EvmEnvFor<Self::Evm>,
         tx_env: TxEnvFor<Self::Evm>,
-    ) -> Result<
-        (ResultAndState<HaltReasonFor<Self::Evm>>, (EvmEnvFor<Self::Evm>, TxEnvFor<Self::Evm>)),
-        Self::Error,
-    >
+    ) -> Result<ResultAndState<HaltReasonFor<Self::Evm>>, Self::Error>
     where
         DB: Database<Error = ProviderError>,
     {
-        let mut evm = self.evm_config().evm_with_env(db, evm_env.clone());
-        let res = evm.transact(tx_env.clone()).map_err(Self::Error::from_evm_err)?;
+        let mut evm = self.evm_config().evm_with_env(db, evm_env);
+        let res = evm.transact(tx_env).map_err(Self::Error::from_evm_err)?;
 
-        Ok((res, (evm_env, tx_env)))
+        Ok(res)
     }
 
     /// Executes the [`EvmEnv`] against the given [Database] without committing state
     /// changes.
-    #[expect(clippy::type_complexity)]
     fn transact_with_inspector<DB, I>(
         &self,
         db: DB,
         evm_env: EvmEnvFor<Self::Evm>,
         tx_env: TxEnvFor<Self::Evm>,
         inspector: I,
-    ) -> Result<
-        (ResultAndState<HaltReasonFor<Self::Evm>>, (EvmEnvFor<Self::Evm>, TxEnvFor<Self::Evm>)),
-        Self::Error,
-    >
+    ) -> Result<ResultAndState<HaltReasonFor<Self::Evm>>, Self::Error>
     where
         DB: Database<Error = ProviderError>,
         I: InspectorFor<Self::Evm, DB>,
     {
-        let mut evm = self.evm_config().evm_with_env_and_inspector(db, evm_env.clone(), inspector);
-        let res = evm.transact(tx_env.clone()).map_err(Self::Error::from_evm_err)?;
+        let mut evm = self.evm_config().evm_with_env_and_inspector(db, evm_env, inspector);
+        let res = evm.transact(tx_env).map_err(Self::Error::from_evm_err)?;
 
-        Ok((res, (evm_env, tx_env)))
+        Ok(res)
     }
 
     /// Executes the call request at the given [`BlockId`].
-    #[expect(clippy::type_complexity)]
     fn transact_call_at(
         &self,
         request: TransactionRequest,
         at: BlockId,
         overrides: EvmOverrides,
-    ) -> impl Future<
-        Output = Result<
-            (ResultAndState<HaltReasonFor<Self::Evm>>, (EvmEnvFor<Self::Evm>, TxEnvFor<Self::Evm>)),
-            Self::Error,
-        >,
-    > + Send
+    ) -> impl Future<Output = Result<ResultAndState<HaltReasonFor<Self::Evm>>, Self::Error>> + Send
     where
         Self: LoadPendingBlock,
     {
@@ -655,7 +641,7 @@ pub trait Call:
 
                 let tx_env = RpcNodeCore::evm_config(&this).tx_env(tx);
 
-                let (res, _) = this.transact(&mut db, evm_env, tx_env)?;
+                let res = this.transact(&mut db, evm_env, tx_env)?;
                 f(tx_info, res, db)
             })
             .await

crates/rpc/rpc-eth-api/src/helpers/estimate.rs

@@ -94,7 +94,7 @@ pub trait EstimateCall: Call {
                         // with the minimum gas limit to make sure.
                         let mut tx_env = tx_env.clone();
                         tx_env.set_gas_limit(MIN_TRANSACTION_GAS);
-                        if let Ok((res, _)) = self.transact(&mut db, evm_env.clone(), tx_env) {
+                        if let Ok(res) = self.transact(&mut db, evm_env.clone(), tx_env) {
                             if res.result.is_success() {
                                 return Ok(U256::from(MIN_TRANSACTION_GAS))
                             }
@@ -119,36 +119,30 @@ pub trait EstimateCall: Call {
         trace!(target: "rpc::eth::estimate", ?evm_env, ?tx_env, "Starting gas estimation");
 
         // Execute the transaction with the highest possible gas limit.
-        let (mut res, (mut evm_env, mut tx_env)) =
-            match self.transact(&mut db, evm_env.clone(), tx_env.clone()) {
-                // Handle the exceptional case where the transaction initialization uses too much
-                // gas. If the gas price or gas limit was specified in the request,
-                // retry the transaction with the block's gas limit to determine if
-                // the failure was due to insufficient gas.
-                Err(err)
-                    if err.is_gas_too_high() &&
-                        (tx_request_gas_limit.is_some() || tx_request_gas_price.is_some()) =>
-                {
-                    return Err(self.map_out_of_gas_err(
-                        block_env_gas_limit,
-                        evm_env,
-                        tx_env,
-                        &mut db,
-                    ))
-                }
-                Err(err) if err.is_gas_too_low() => {
-                    // This failed because the configured gas cost of the tx was lower than what
-                    // actually consumed by the tx This can happen if the
-                    // request provided fee values manually and the resulting gas cost exceeds the
-                    // sender's allowance, so we return the appropriate error here
-                    return Err(RpcInvalidTransactionError::GasRequiredExceedsAllowance {
-                        gas_limit: tx_env.gas_limit(),
-                    }
-                    .into_eth_err())
+        let mut res = match self.transact(&mut db, evm_env.clone(), tx_env.clone()) {
+            // Handle the exceptional case where the transaction initialization uses too much
+            // gas. If the gas price or gas limit was specified in the request,
+            // retry the transaction with the block's gas limit to determine if
+            // the failure was due to insufficient gas.
+            Err(err)
+                if err.is_gas_too_high() &&
+                    (tx_request_gas_limit.is_some() || tx_request_gas_price.is_some()) =>
+            {
+                return Err(self.map_out_of_gas_err(block_env_gas_limit, evm_env, tx_env, &mut db))
+            }
+            Err(err) if err.is_gas_too_low() => {
+                // This failed because the configured gas cost of the tx was lower than what
+                // actually consumed by the tx This can happen if the
+                // request provided fee values manually and the resulting gas cost exceeds the
+                // sender's allowance, so we return the appropriate error here
+                return Err(RpcInvalidTransactionError::GasRequiredExceedsAllowance {
+                    gas_limit: tx_env.gas_limit(),
                 }
-                // Propagate other results (successful or other errors).
-                ethres => ethres?,
-            };
+                .into_eth_err())
+            }
+            // Propagate other results (successful or other errors).
+            ethres => ethres?,
+        };
 
         let gas_refund = match res.result {
             ExecutionResult::Success { gas_refunded, .. } => gas_refunded,
@@ -194,7 +188,7 @@ pub trait EstimateCall: Call {
             tx_env.set_gas_limit(optimistic_gas_limit);
             // Re-execute the transaction with the new gas limit and update the result and
             // environment.
-            (res, (evm_env, tx_env)) = self.transact(&mut db, evm_env, tx_env)?;
+            res = self.transact(&mut db, evm_env.clone(), tx_env.clone())?;
             // Update the gas used based on the new result.
             gas_used = res.result.gas_used();
             // Update the gas limit estimates (highest and lowest) based on the execution result.
@@ -241,7 +235,7 @@ pub trait EstimateCall: Call {
                 // Handle other cases, including successful transactions.
                 ethres => {
                     // Unpack the result and environment if the transaction was successful.
-                    (res, (evm_env, tx_env)) = ethres?;
+                    res = ethres?;
                     // Update the estimated gas range based on the transaction result.
                     update_estimated_gas_range(
                         res.result,
@@ -296,7 +290,7 @@ pub trait EstimateCall: Call {
     {
         let req_gas_limit = tx_env.gas_limit();
         tx_env.set_gas_limit(env_gas_limit);
-        let (res, _) = match self.transact(db, evm_env, tx_env) {
+        let res = match self.transact(db, evm_env, tx_env) {
             Ok(res) => res,
             Err(err) => return err,
         };

crates/rpc/rpc/src/debug.rs

@@ -528,7 +528,7 @@ where
                     // Execute all transactions until index
                     for tx in transactions {
                         let tx_env = this.eth_api().evm_config().tx_env(tx);
-                        let (res, _) = this.eth_api().transact(&mut db, evm_env.clone(), tx_env)?;
+                        let res = this.eth_api().transact(&mut db, evm_env.clone(), tx_env)?;
                         db.commit(res.state);
                     }
                 }