Add options for state changes output and json output in cast run command

crates/cast/bin/cmd/call.rs

@@ -182,8 +182,15 @@ impl CallArgs {
             env.cfg.disable_block_gas_limit = true;
             env.block.gas_limit = U256::MAX;
 
-            let mut executor =
-                TracingExecutor::new(env, fork, evm_version, debug, decode_internal, alphanet);
+            let mut executor = TracingExecutor::new(
+                env,
+                fork,
+                evm_version,
+                debug,
+                decode_internal,
+                false,
+                alphanet,
+            );
 
             let value = tx.value.unwrap_or_default();
             let input = tx.inner.input.into_input().unwrap_or_default();
@@ -200,7 +207,18 @@ impl CallArgs {
                 ),
             };
 
-            handle_traces(trace, &config, chain, labels, debug, decode_internal, false).await?;
+            handle_traces(
+                trace,
+                &config,
+                chain,
+                labels,
+                debug,
+                decode_internal,
+                false,
+                false,
+                false,
+            )
+            .await?;
 
             return Ok(());
         }

crates/cast/bin/cmd/run.rs

@@ -52,6 +52,14 @@ pub struct RunArgs {
     #[arg(long, short)]
     verbose: bool,
 
+    /// Prints the trace in JSON format.
+    #[arg(long, short)]
+    json: bool,
+
+    /// Prints the state changes
+    #[arg(long)]
+    with_state_changes: bool,
+
     /// Label addresses in the trace.
     ///
     /// Example: 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045:vitalik.eth
@@ -163,14 +171,17 @@ impl RunArgs {
             evm_version,
             self.debug,
             self.decode_internal,
+            self.with_state_changes,
             alphanet,
         );
         let mut env =
             EnvWithHandlerCfg::new_with_spec_id(Box::new(env.clone()), executor.spec_id());
 
         // Set the state to the moment right before the transaction
         if !self.quick {
-            sh_println!("Executing previous transactions from the block.")?;
+            if !self.json {
+                sh_println!("Executing previous transactions from the block.")?;
+            }
 
             if let Some(block) = block {
                 let pb = init_progress(block.transactions.len() as u64, "tx");
@@ -250,6 +261,8 @@ impl RunArgs {
             self.debug,
             self.decode_internal,
             self.verbose,
+            self.json,
+            self.with_state_changes,
         )
         .await?;
 

crates/cli/src/utils/cmd.rs

@@ -17,8 +17,7 @@ use foundry_evm::{
         debug::DebugTraceIdentifier,
         decode_trace_arena,
         identifier::{EtherscanIdentifier, SignaturesIdentifier},
-        render_trace_arena_with_bytecodes, CallTraceDecoder, CallTraceDecoderBuilder, TraceKind,
-        Traces,
+        render_trace_arena_inner, CallTraceDecoder, CallTraceDecoderBuilder, TraceKind, Traces,
     },
 };
 use std::{
@@ -380,6 +379,7 @@ impl TryFrom<Result<RawCallResult>> for TraceResult {
 }
 
 /// labels the traces, conditionally prints them or opens the debugger
+#[allow(clippy::too_many_arguments)]
 pub async fn handle_traces(
     mut result: TraceResult,
     config: &Config,
@@ -388,6 +388,8 @@ pub async fn handle_traces(
     debug: bool,
     decode_internal: bool,
     verbose: bool,
+    json: bool,
+    with_state_changes: bool,
 ) -> Result<()> {
     let labels = labels.iter().filter_map(|label_str| {
         let mut iter = label_str.split(':');
@@ -437,7 +439,7 @@ pub async fn handle_traces(
             .build();
         debugger.try_run_tui()?;
     } else {
-        print_traces(&mut result, &decoder, verbose).await?;
+        print_traces(&mut result, &decoder, verbose, json, with_state_changes).await?;
     }
 
     Ok(())
@@ -447,22 +449,33 @@ pub async fn print_traces(
     result: &mut TraceResult,
     decoder: &CallTraceDecoder,
     verbose: bool,
+    json: bool,
+    state_changes: bool,
 ) -> Result<()> {
     let traces = result.traces.as_mut().expect("No traces found");
 
-    println!("Traces:");
+    if !json {
+        println!("Traces:");
+    }
+
     for (_, arena) in traces {
         decode_trace_arena(arena, decoder).await?;
-        println!("{}", render_trace_arena_with_bytecodes(arena, verbose));
+        println!("{}", render_trace_arena_inner(arena, verbose, json, state_changes));
     }
-    println!();
 
-    if result.success {
-        println!("{}", "Transaction successfully executed.".green());
-    } else {
-        println!("{}", "Transaction failed.".red());
+    if json {
+        return Ok(());
+    }
+
+    if !json {
+        println!();
+        if result.success {
+            println!("{}", "Transaction successfully executed.".green());
+        } else {
+            println!("{}", "Transaction failed.".red());
+        }
+        println!("Gas used: {}", result.gas_used);
     }
 
-    println!("Gas used: {}", result.gas_used);
     Ok(())
 }

crates/evm/evm/src/executors/trace.rs

@@ -18,15 +18,18 @@ impl TracingExecutor {
         version: Option<EvmVersion>,
         debug: bool,
         decode_internal: bool,
+        with_state_changes: bool,
         alphanet: bool,
     ) -> Self {
         let db = Backend::spawn(fork);
-        let trace_mode =
-            TraceMode::Call.with_debug(debug).with_decode_internal(if decode_internal {
+        let trace_mode = TraceMode::Call
+            .with_debug(debug)
+            .with_decode_internal(if decode_internal {
                 InternalTraceMode::Full
             } else {
                 InternalTraceMode::None
-            });
+            })
+            .with_state_changes(with_state_changes);
         Self {
             // configures a bare version of the evm executor: no cheatcode inspector is enabled,
             // tracing will be enabled only for the targeted transaction

crates/evm/traces/Cargo.toml

@@ -36,6 +36,7 @@ eyre.workspace = true
 futures.workspace = true
 itertools.workspace = true
 serde.workspace = true
+serde_json.workspace = true
 tokio = { workspace = true, features = ["time", "macros"] }
 tracing.workspace = true
 tempfile.workspace = true

crates/evm/traces/src/lib.rs

@@ -180,15 +180,24 @@ pub async fn decode_trace_arena(
 
 /// Render a collection of call traces to a string.
 pub fn render_trace_arena(arena: &SparsedTraceArena) -> String {
-    render_trace_arena_with_bytecodes(arena, false)
+    render_trace_arena_inner(arena, false, false, false)
 }
 
-/// Render a collection of call traces to a string optionally including contract creation bytecodes.
-pub fn render_trace_arena_with_bytecodes(
+/// Render a collection of call traces to a string optionally including contract creation bytecodes
+/// and in JSON format.
+pub fn render_trace_arena_inner(
     arena: &SparsedTraceArena,
     with_bytecodes: bool,
+    to_json: bool,
+    with_storage_changes: bool,
 ) -> String {
-    let mut w = TraceWriter::new(Vec::<u8>::new()).write_bytecodes(with_bytecodes);
+    if to_json {
+        return serde_json::to_string(&arena.resolve_arena()).expect("Failed to write traces");
+    }
+
+    let mut w = TraceWriter::new(Vec::<u8>::new())
+        .write_bytecodes(with_bytecodes)
+        .with_storage_changes(with_storage_changes);
     w.write_arena(&arena.resolve_arena()).expect("Failed to write traces");
     String::from_utf8(w.into_writer()).expect("trace writer wrote invalid UTF-8")
 }
@@ -286,6 +295,8 @@ pub enum TraceMode {
     ///
     /// Used by debugger.
     Debug,
+    /// Debug trace with storage changes.
+    RecordStateDiff,
 }
 
 impl TraceMode {
@@ -305,6 +316,10 @@ impl TraceMode {
         matches!(self, Self::Jump)
     }
 
+    pub const fn record_state_diff(self) -> bool {
+        matches!(self, Self::RecordStateDiff)
+    }
+
     pub const fn is_debug(self) -> bool {
         matches!(self, Self::Debug)
     }
@@ -321,6 +336,14 @@ impl TraceMode {
         std::cmp::max(self, mode.into())
     }
 
+    pub fn with_state_changes(self, yes: bool) -> Self {
+        if yes {
+            std::cmp::max(self, Self::RecordStateDiff)
+        } else {
+            self
+        }
+    }
+
     pub fn with_verbosity(self, verbosiy: u8) -> Self {
         if verbosiy >= 3 {
             std::cmp::max(self, Self::Call)
@@ -342,7 +365,7 @@ impl TraceMode {
                     StackSnapshotType::None
                 },
                 record_logs: true,
-                record_state_diff: false,
+                record_state_diff: self.record_state_diff(),
                 record_returndata_snapshots: self.is_debug(),
                 record_opcodes_filter: (self.is_jump() || self.is_jump_simple())
                     .then(|| OpcodeFilter::new().enabled(OpCode::JUMP).enabled(OpCode::JUMPDEST)),

crates/verify/src/utils.rs

@@ -340,6 +340,7 @@ pub async fn get_tracing_executor(
         Some(fork_config.evm_version),
         false,
         false,
+        false,
         is_alphanet,
     );