chore(deps): bump revm 30+, alloy-evm, revm-inspectors

Cargo.toml

@@ -228,7 +228,7 @@ foundry-compilers = { version = "0.19.5", default-features = false, features = [
     "rustls",
     "svm-solc",
 ] }
-foundry-fork-db = "0.18"
+foundry-fork-db = "0.19"
 solang-parser = { version = "=0.3.9", package = "foundry-solang-parser" }
 solar = { package = "solar-compiler", version = "=0.1.8", default-features = false }
 svm = { package = "svm-rs", version = "0.5", default-features = false, features = [
@@ -286,12 +286,12 @@ op-alloy-rpc-types = "0.20.0"
 op-alloy-flz = "0.13.1"
 
 ## revm
-revm = { version = "29.0.0", default-features = false }
-revm-inspectors = { version = "0.30.0", features = ["serde"] }
-op-revm = { version = "10.0.0", default-features = false }
+revm = { version = "30.2.0", default-features = false }
+revm-inspectors = { version = "0.31.2", features = ["serde"] }
+op-revm = { version = "11.1.2", default-features = false }
 ## alloy-evm
-alloy-evm = "0.21.1"
-alloy-op-evm = "0.21.1"
+alloy-evm = "0.22.3"
+alloy-op-evm = "0.22.3"
 
 ## cli
 anstream = "0.6"
@@ -435,18 +435,18 @@ rexpect = { git = "https://github.com/rust-cli/rexpect", rev = "2ed0b1898d7edaf6
 # alloy-transport-ws = { git = "https://github.com/alloy-rs/alloy", rev = "7fab7ee" }
 
 ## alloy-evm
-# alloy-evm = { git = "https://github.com/alloy-rs/evm.git", rev = "3c6cebb" }
-# alloy-op-evm = { git = "https://github.com/alloy-rs/evm.git", rev = "3c6cebb" }
+# alloy-evm = { git = "https://github.com/alloy-rs/evm.git", rev = "085ad53" }
+# alloy-op-evm = { git = "https://github.com/alloy-rs/evm.git", rev = "085ad53" }
 
 ## revm
 # revm = { git = "https://github.com/bluealloy/revm.git", rev = "d9cda3a" }
 # op-revm = { git = "https://github.com/bluealloy/revm.git", rev = "d9cda3a" }
-# revm-inspectors = { git = "https://github.com/zerosnacks/revm-inspectors.git", rev = "74e215d" }
+# revm-inspectors = { git = "https://github.com/zerosnacks/revm-inspectors.git", rev = "340d37e" }
 
 ## foundry
 # foundry-block-explorers = { git = "https://github.com/foundry-rs/block-explorers.git", rev = "f5b46b2" }
 # foundry-compilers = { git = "https://github.com/foundry-rs/compilers.git", branch = "main" }
-# foundry-fork-db = { git = "https://github.com/foundry-rs/foundry-fork-db", rev = "eee6563" }
+# foundry-fork-db = { git = "https://github.com/foundry-rs/foundry-fork-db", rev = "be95912" }
 
 # solar
 # solar = { package = "solar-compiler", git = "https://github.com/paradigmxyz/solar.git", branch = "main" }

crates/anvil/src/eth/backend/mem/mod.rs

@@ -3712,7 +3712,10 @@ impl TransactionValidator for Backend {
                 && max_fee_per_blob_gas < blob_gas_and_price.blob_gasprice
             {
                 warn!(target: "backend", "max fee per blob gas={}, too low, block blob gas price={}", max_fee_per_blob_gas, blob_gas_and_price.blob_gasprice);
-                return Err(InvalidTransactionError::BlobFeeCapTooLow);
+                return Err(InvalidTransactionError::BlobFeeCapTooLow(
+                    max_fee_per_blob_gas,
+                    blob_gas_and_price.blob_gasprice,
+                ));
             }
 
             let max_cost = tx.max_cost();

crates/anvil/src/eth/error.rs

@@ -284,7 +284,7 @@ pub enum InvalidTransactionError {
     /// Thrown when the block's `blob_gas_price` is greater than tx-specified
     /// `max_fee_per_blob_gas` after Cancun.
     #[error("Block `blob_gas_price` is greater than tx-specified `max_fee_per_blob_gas`")]
-    BlobFeeCapTooLow,
+    BlobFeeCapTooLow(u128, u128),
     /// Thrown when we receive a tx with `blob_versioned_hashes` and we're not on the Cancun hard
     /// fork.
     #[error("Block `blob_versioned_hashes` is not supported before the Cancun hardfork")]
@@ -345,7 +345,10 @@ impl From<InvalidTransaction> for InvalidTransactionError {
             InvalidTransaction::NonceTooHigh { .. } => Self::NonceTooHigh,
             InvalidTransaction::NonceTooLow { .. } => Self::NonceTooLow,
             InvalidTransaction::AccessListNotSupported => Self::AccessListNotSupported,
-            InvalidTransaction::BlobGasPriceGreaterThanMax => Self::BlobFeeCapTooLow,
+            InvalidTransaction::BlobGasPriceGreaterThanMax {
+                block_blob_gas_price,
+                tx_max_fee_per_blob_gas,
+            } => Self::BlobFeeCapTooLow(block_blob_gas_price, tx_max_fee_per_blob_gas),
             InvalidTransaction::BlobVersionedHashesNotSupported => {
                 Self::BlobVersionedHashesNotSupported
             }
@@ -369,7 +372,8 @@ impl From<InvalidTransaction> for InvalidTransactionError {
             | InvalidTransaction::EmptyAuthorizationList
             | InvalidTransaction::Eip7873NotSupported
             | InvalidTransaction::Eip7873MissingTarget
-            | InvalidTransaction::MissingChainId => Self::Revm(err),
+            | InvalidTransaction::MissingChainId
+            | InvalidTransaction::Str(_) => Self::Revm(err),
         }
     }
 }

crates/cheatcodes/src/evm.rs

@@ -47,7 +47,7 @@ use std::{
 mod record_debug_step;
 use foundry_common::fmt::format_token_raw;
 use foundry_config::evm_spec_id;
-use record_debug_step::{convert_call_trace_to_debug_step, flatten_call_trace};
+use record_debug_step::{convert_call_trace_ctx_to_debug_step, flatten_call_trace};
 use serde::Serialize;
 
 mod fork;
@@ -1085,7 +1085,7 @@ impl Cheatcode for stopAndReturnDebugTraceRecordingCall {
         let steps = flatten_call_trace(0, root, record_info.start_node_idx);
 
         let debug_steps: Vec<DebugStep> =
-            steps.iter().map(|&step| convert_call_trace_to_debug_step(step)).collect();
+            steps.iter().map(|step| convert_call_trace_ctx_to_debug_step(step)).collect();
         // Free up memory by clearing the steps if they are not recorded outside of cheatcode usage.
         if !record_info.original_tracer_config.record_steps {
             tracer.traces_mut().nodes_mut().iter_mut().for_each(|node| {

crates/cheatcodes/src/evm/record_debug_step.rs

@@ -4,16 +4,24 @@ use foundry_evm_traces::CallTraceArena;
 use revm::{bytecode::opcode::OpCode, interpreter::InstructionResult};
 
 use foundry_evm_core::buffer::{BufferKind, get_buffer_accesses};
-use revm_inspectors::tracing::types::{CallTraceStep, RecordedMemory, TraceMemberOrder};
+use revm_inspectors::tracing::types::{
+    CallTraceNode, CallTraceStep, RecordedMemory, TraceMemberOrder,
+};
 use spec::Vm::DebugStep;
 
+// Context for a CallTraceStep, includes depth and contract address.
+pub(crate) struct CallTraceCtx<'a> {
+    pub node: &'a CallTraceNode,
+    pub step: &'a CallTraceStep,
+}
+
 // Do a depth first traverse of the nodes and steps and return steps
 // that are after `node_start_idx`
-pub(crate) fn flatten_call_trace(
+pub(crate) fn flatten_call_trace<'a>(
     root: usize,
-    arena: &CallTraceArena,
+    arena: &'a CallTraceArena,
     node_start_idx: usize,
-) -> Vec<&CallTraceStep> {
+) -> Vec<CallTraceCtx<'a>> {
     let mut steps = Vec::new();
     let mut record_started = false;
 
@@ -31,7 +39,7 @@ fn recursive_flatten_call_trace<'a>(
     arena: &'a CallTraceArena,
     node_start_idx: usize,
     record_started: &mut bool,
-    flatten_steps: &mut Vec<&'a CallTraceStep>,
+    flatten_steps: &mut Vec<CallTraceCtx<'a>>,
 ) {
     // Once node_idx exceeds node_start_idx, start recording steps
     // for all the recursive processing.
@@ -46,7 +54,7 @@ fn recursive_flatten_call_trace<'a>(
             TraceMemberOrder::Step(step_idx) => {
                 if *record_started {
                     let step = &node.trace.steps[*step_idx];
-                    flatten_steps.push(step);
+                    flatten_steps.push(CallTraceCtx { node, step });
                 }
             }
             TraceMemberOrder::Call(call_idx) => {
@@ -65,25 +73,34 @@ fn recursive_flatten_call_trace<'a>(
 }
 
 // Function to convert CallTraceStep to DebugStep
-pub(crate) fn convert_call_trace_to_debug_step(step: &CallTraceStep) -> DebugStep {
-    let opcode = step.op.get();
-    let stack = get_stack_inputs_for_opcode(opcode, step.stack.as_deref());
-
-    let memory = get_memory_input_for_opcode(opcode, step.stack.as_deref(), step.memory.as_ref());
-
-    let is_out_of_gas = step.status == Some(InstructionResult::OutOfGas)
-        || step.status == Some(InstructionResult::MemoryOOG)
-        || step.status == Some(InstructionResult::MemoryLimitOOG)
-        || step.status == Some(InstructionResult::PrecompileOOG)
-        || step.status == Some(InstructionResult::InvalidOperandOOG);
+pub(crate) fn convert_call_trace_ctx_to_debug_step(ctx: &CallTraceCtx) -> DebugStep {
+    let opcode = ctx.step.op.get();
+    let stack = get_stack_inputs_for_opcode(opcode, ctx.step.stack.as_deref());
+
+    let memory =
+        get_memory_input_for_opcode(opcode, ctx.step.stack.as_deref(), ctx.step.memory.as_ref());
+
+    let is_out_of_gas = matches!(
+        ctx.step.status,
+        Some(
+            InstructionResult::OutOfGas
+                | InstructionResult::MemoryOOG
+                | InstructionResult::MemoryLimitOOG
+                | InstructionResult::PrecompileOOG
+                | InstructionResult::InvalidOperandOOG
+        )
+    );
+
+    let depth = ctx.node.trace.depth as u64 + 1;
+    let contract_addr = ctx.node.execution_address();
 
     DebugStep {
         stack,
         memoryInput: memory,
-        opcode: step.op.get(),
-        depth: step.depth,
+        opcode: ctx.step.op.get(),
+        depth,
         isOutOfGas: is_out_of_gas,
-        contractAddr: step.contract,
+        contractAddr: contract_addr,
     }
 }
 

crates/cheatcodes/src/inspector.rs

@@ -4,7 +4,7 @@ use crate::{
     CheatsConfig, CheatsCtxt, DynCheatcode, Error, Result,
     Vm::{self, AccountAccess},
     evm::{
-        DealRecord, GasRecord, RecordAccess,
+        DealRecord, GasRecord, RecordAccess, journaled_account,
         mock::{MockCallDataContext, MockCallReturnData},
         prank::Prank,
     },
@@ -835,6 +835,8 @@ impl Cheatcodes {
 
                 // At the target depth we set `msg.sender`
                 if curr_depth == prank.depth {
+                    // Ensure new caller is loaded and touched
+                    let _ = journaled_account(ecx, prank.new_caller);
                     call.caller = prank.new_caller;
                     prank_applied = true;
                 }
@@ -1636,6 +1638,8 @@ impl Inspector<EthEvmContext<&mut dyn DatabaseExt>> for Cheatcodes {
 
             // At the target depth we set `msg.sender`
             if curr_depth == prank.depth {
+                // Ensure new caller is loaded and touched
+                let _ = journaled_account(ecx, prank.new_caller);
                 input.set_caller(prank.new_caller);
                 prank_applied = true;
             }

crates/evm/core/src/either_evm.rs

@@ -106,6 +106,7 @@ where
     type Inspector = I;
     type Precompiles = P;
     type Spec = SpecId;
+    type BlockEnv = BlockEnv;
 
     fn block(&self) -> &BlockEnv {
         match self {

crates/evm/core/src/evm.rs

@@ -105,6 +105,7 @@ fn get_create2_factory_call_inputs(
     CallInputs {
         caller: inputs.caller,
         bytecode_address: deployer,
+        known_bytecode: None,
         target_address: deployer,
         scheme: CallScheme::Call,
         value: CallValue::Transfer(inputs.value),
@@ -160,6 +161,7 @@ impl<'db, I: InspectorExt> Evm for FoundryEvm<'db, I> {
     type HaltReason = HaltReason;
     type Spec = SpecId;
     type Tx = TxEnv;
+    type BlockEnv = BlockEnv;
 
     fn block(&self) -> &BlockEnv {
         &self.inner.block

crates/evm/evm/src/inspectors/custom_printer.rs

@@ -62,7 +62,7 @@ where
     }
 
     fn step_end(&mut self, interpreter: &mut Interpreter, _context: &mut CTX) {
-        self.gas_inspector.step_end(&mut interpreter.gas);
+        self.gas_inspector.step_end(&interpreter.gas);
     }
 
     fn call_end(&mut self, _context: &mut CTX, _inputs: &CallInputs, outcome: &mut CallOutcome) {

crates/evm/evm/src/inspectors/stack.rs

@@ -962,6 +962,7 @@ impl Inspector<EthEvmContext<&mut dyn DatabaseExt>> for InspectorStackRefMut<'_>
                     call.input.bytes(ecx).get(..4).and_then(|selector| mocks.get(selector))
                 }) {
                     call.bytecode_address = *target;
+                    call.known_bytecode = None;
                 }
             }
 

crates/forge/tests/cli/script.rs

@@ -3258,5 +3258,88 @@ ONCHAIN EXECUTION COMPLETE & SUCCESSFUL.
 [SAVED_SENSITIVE_VALUES]
 
 
+"#]]);
+});
+
+forgetest_async!(can_deploy_with_broadcast_in_setup, |prj, cmd| {
+    foundry_test_utils::util::initialize(prj.root());
+    prj.add_script(
+        "Deploy.s.sol",
+        r#"
+import "forge-std/Script.sol";
+import {Vm} from "forge-std/Vm.sol";
+contract DeployScript is Script {
+    function setUp() public {
+        vm.startBroadcast();
+    }
+
+    function run() public {
+        payable(address(0)).transfer(1 ether);
+
+        vm.stopBroadcast();
+    }
+}
+   "#,
+    );
+
+    let node_config = NodeConfig::test().with_hardfork(Some(EthereumHardfork::Prague.into()));
+    let (_api, handle) = spawn(node_config).await;
+
+    cmd.args([
+        "script",
+        "script/Deploy.s.sol:DeployScript",
+        "--rpc-url",
+        &handle.http_endpoint(),
+        "-vvvv",
+        "--broadcast",
+        "--private-key",
+        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
+    ])
+    .assert_success()
+    .stdout_eq(str![[r#"
+[COMPILING_FILES] with [SOLC_VERSION]
+[SOLC_VERSION] [ELAPSED]
+Compiler run successful!
+Traces:
+  [9882] DeployScript::run()
+    ├─ [0] 0x0000000000000000000000000000000000000000::fallback{value: 1000000000000000000}()
+    │   └─ ← [Stop]
+    ├─ [0] VM::stopBroadcast()
+    │   └─ ← [Return]
+    └─ ← [Stop]
+
+
+Script ran successfully.
+
+## Setting up 1 EVM.
+==========================
+Simulated On-chain Traces:
+
+  [0] 0x0000000000000000000000000000000000000000::fallback{value: 1000000000000000000}()
+    └─ ← [Stop]
+
+
+==========================
+
+Chain 31337
+
+[ESTIMATED_GAS_PRICE]
+
+[ESTIMATED_TOTAL_GAS_USED]
+
+[ESTIMATED_AMOUNT_REQUIRED]
+
+==========================
+
+
+==========================
+
+ONCHAIN EXECUTION COMPLETE & SUCCESSFUL.
+
+[SAVED_TRANSACTIONS]
+
+[SAVED_SENSITIVE_VALUES]
+
+
 "#]]);
 });