fix(forge): verify bytecode should replay txes (#12068)

* fix(forge): verify bytecode should replay txes

* Cleanup

Author: grandizzy

crates/verify/src/bytecode.rs

@@ -11,10 +11,12 @@ use alloy_primitives::{Address, Bytes, TxKind, U256, hex};
 use alloy_provider::{
     Provider,
     ext::TraceApi,
-    network::{AnyTxEnvelope, TransactionBuilder},
+    network::{
+        AnyTxEnvelope, TransactionBuilder, TransactionResponse, primitives::BlockTransactions,
+    },
 };
 use alloy_rpc_types::{
-    BlockId, BlockNumberOrTag, TransactionInput, TransactionRequest,
+    BlockId, BlockNumberOrTag, TransactionInput, TransactionRequest, TransactionTrait,
     trace::parity::{Action, CreateAction, CreateOutput, TraceOutput},
 };
 use clap::{Parser, ValueHint};
@@ -23,11 +25,14 @@ use foundry_cli::{
     opts::EtherscanOpts,
     utils::{self, LoadConfig, read_constructor_args_file},
 };
-use foundry_common::shell;
+use foundry_common::{SYSTEM_TRANSACTION_TYPE, is_known_system_sender, shell};
 use foundry_compilers::{artifacts::EvmVersion, info::ContractInfo};
 use foundry_config::{Config, figment, impl_figment_convert};
 use foundry_evm::{
-    constants::DEFAULT_CREATE2_DEPLOYER, core::AsEnvMut, utils::configure_tx_req_env,
+    constants::DEFAULT_CREATE2_DEPLOYER,
+    core::AsEnvMut,
+    executors::EvmError,
+    utils::{configure_tx_env, configure_tx_req_env},
 };
 use revm::state::AccountInfo;
 use std::path::PathBuf;
@@ -323,6 +328,7 @@ impl VerifyBytecodeArgs {
             .ok_or_else(|| {
                 eyre::eyre!("Transaction not found for hash {}", creation_data.transaction_hash)
             })?;
+        let tx_hash = transaction.tx_hash();
         let receipt = provider
             .get_transaction_receipt(creation_data.transaction_hash)
             .await
@@ -478,7 +484,50 @@ impl VerifyBytecodeArgs {
             transaction.set_nonce(prev_block_nonce);
 
             if let Some(ref block) = block {
-                configure_env_block(&mut env.as_env_mut(), block)
+                configure_env_block(&mut env.as_env_mut(), block);
+
+                let BlockTransactions::Full(ref txs) = block.transactions else {
+                    return Err(eyre::eyre!("Could not get block txs"));
+                };
+
+                // Replay txes in block until the contract creation one.
+                for tx in txs {
+                    trace!("replay tx::: {}", tx.tx_hash());
+                    if is_known_system_sender(tx.from())
+                        || tx.transaction_type() == Some(SYSTEM_TRANSACTION_TYPE)
+                    {
+                        continue;
+                    }
+                    if tx.tx_hash() == tx_hash {
+                        break;
+                    }
+
+                    configure_tx_env(&mut env.as_env_mut(), &tx.inner);
+
+                    if let TxKind::Call(_) = tx.inner.kind() {
+                        executor.transact_with_env(env.clone()).wrap_err_with(|| {
+                            format!(
+                                "Failed to execute transaction: {:?} in block {}",
+                                tx.tx_hash(),
+                                env.evm_env.block_env.number
+                            )
+                        })?;
+                    } else if let Err(error) = executor.deploy_with_env(env.clone(), None) {
+                        match error {
+                            // Reverted transactions should be skipped
+                            EvmError::Execution(_) => (),
+                            error => {
+                                return Err(error).wrap_err_with(|| {
+                                    format!(
+                                        "Failed to deploy transaction: {:?} in block {}",
+                                        tx.tx_hash(),
+                                        env.evm_env.block_env.number
+                                    )
+                                });
+                            }
+                        }
+                    }
+                }
             }
 
             // Replace the `input` with local creation code in the creation tx.

crates/verify/src/utils.rs

@@ -1,7 +1,10 @@
 use crate::{bytecode::VerifyBytecodeArgs, types::VerificationType};
 use alloy_dyn_abi::DynSolValue;
 use alloy_primitives::{Address, Bytes, TxKind, U256};
-use alloy_provider::{Provider, network::AnyRpcBlock};
+use alloy_provider::{
+    Provider,
+    network::{AnyNetwork, AnyRpcBlock},
+};
 use alloy_rpc_types::BlockId;
 use clap::ValueEnum;
 use eyre::{OptionExt, Result};
@@ -17,8 +20,8 @@ use foundry_common::{
 use foundry_compilers::artifacts::{BytecodeHash, CompactContractBytecode, EvmVersion};
 use foundry_config::Config;
 use foundry_evm::{
-    Env, EnvMut, constants::DEFAULT_CREATE2_DEPLOYER, executors::TracingExecutor, opts::EvmOpts,
-    traces::TraceMode,
+    Env, EnvMut, constants::DEFAULT_CREATE2_DEPLOYER, core::AsEnvMut, executors::TracingExecutor,
+    opts::EvmOpts, traces::TraceMode, utils::apply_chain_and_block_specific_env_changes,
 };
 use reqwest::Url;
 use revm::{bytecode::Bytecode, database::Database, primitives::hardfork::SpecId};
@@ -335,6 +338,7 @@ pub fn configure_env_block(env: &mut EnvMut<'_>, block: &AnyRpcBlock) {
     env.block.prevrandao = Some(block.header.mix_hash.unwrap_or_default());
     env.block.basefee = block.header.base_fee_per_gas.unwrap_or_default();
     env.block.gas_limit = block.header.gas_limit;
+    apply_chain_and_block_specific_env_changes::<AnyNetwork>(env.as_env_mut(), block);
 }
 
 pub fn deploy_contract(