refactor: move handle_traces into cast (#11775)

Author: onbjerg

Cargo.lock

@@ -26,6 +26,7 @@ foundry-block-explorers.workspace = true
 foundry-common.workspace = true
 foundry-compilers.workspace = true
 foundry-config.workspace = true
+foundry-debugger.workspace = true
 foundry-evm-core.workspace = true
 foundry-evm.workspace = true
 foundry-wallets.workspace = true

crates/cast/Cargo.toml

@@ -1,6 +1,7 @@
 use super::run::fetch_contracts_bytecode_from_trace;
 use crate::{
     Cast,
+    debug::handle_traces,
     traces::TraceKind,
     tx::{CastTxBuilder, SenderKind},
 };
@@ -15,7 +16,7 @@ use clap::Parser;
 use eyre::Result;
 use foundry_cli::{
     opts::{EthereumOpts, TransactionOpts},
-    utils::{self, TraceResult, handle_traces, parse_ether_value},
+    utils::{self, TraceResult, parse_ether_value},
 };
 use foundry_common::shell;
 use foundry_compilers::artifacts::EvmVersion;

crates/cast/src/cmd/call.rs

@@ -1,3 +1,4 @@
+use crate::debug::handle_traces;
 use alloy_consensus::Transaction;
 use alloy_network::{AnyNetwork, TransactionResponse};
 use alloy_primitives::{
@@ -10,7 +11,7 @@ use clap::Parser;
 use eyre::{Result, WrapErr};
 use foundry_cli::{
     opts::{EtherscanOpts, RpcOpts},
-    utils::{TraceResult, handle_traces, init_progress},
+    utils::{TraceResult, init_progress},
 };
 use foundry_common::{SYSTEM_TRANSACTION_TYPE, is_impersonated_tx, is_known_system_sender, shell};
 use foundry_compilers::artifacts::EvmVersion;

crates/cast/src/cmd/run.rs

@@ -0,0 +1,92 @@
+use std::str::FromStr;
+
+use alloy_chains::Chain;
+use alloy_primitives::{Address, Bytes, map::HashMap};
+use foundry_cli::utils::{TraceResult, print_traces};
+use foundry_common::{ContractsByArtifact, compile::ProjectCompiler, shell};
+use foundry_config::Config;
+use foundry_debugger::Debugger;
+use foundry_evm::traces::{
+    CallTraceDecoderBuilder, DebugTraceIdentifier,
+    debug::ContractSources,
+    identifier::{SignaturesIdentifier, TraceIdentifiers},
+};
+
+/// labels the traces, conditionally prints them or opens the debugger
+#[expect(clippy::too_many_arguments)]
+pub(crate) async fn handle_traces(
+    mut result: TraceResult,
+    config: &Config,
+    chain: Option<Chain>,
+    contracts_bytecode: &HashMap<Address, Bytes>,
+    labels: Vec<String>,
+    with_local_artifacts: bool,
+    debug: bool,
+    decode_internal: bool,
+    disable_label: bool,
+) -> eyre::Result<()> {
+    let (known_contracts, mut sources) = if with_local_artifacts {
+        let _ = sh_println!("Compiling project to generate artifacts");
+        let project = config.project()?;
+        let compiler = ProjectCompiler::new();
+        let output = compiler.compile(&project)?;
+        (
+            Some(ContractsByArtifact::new(
+                output.artifact_ids().map(|(id, artifact)| (id, artifact.clone().into())),
+            )),
+            ContractSources::from_project_output(&output, project.root(), None)?,
+        )
+    } else {
+        (None, ContractSources::default())
+    };
+
+    let labels = labels.iter().filter_map(|label_str| {
+        let mut iter = label_str.split(':');
+
+        if let Some(addr) = iter.next()
+            && let (Ok(address), Some(label)) = (Address::from_str(addr), iter.next())
+        {
+            return Some((address, label.to_string()));
+        }
+        None
+    });
+    let config_labels = config.labels.clone().into_iter();
+
+    let mut builder = CallTraceDecoderBuilder::new()
+        .with_labels(labels.chain(config_labels))
+        .with_signature_identifier(SignaturesIdentifier::from_config(config)?)
+        .with_label_disabled(disable_label);
+    let mut identifier = TraceIdentifiers::new().with_etherscan(config, chain)?;
+    if let Some(contracts) = &known_contracts {
+        builder = builder.with_known_contracts(contracts);
+        identifier = identifier.with_local_and_bytecodes(contracts, contracts_bytecode);
+    }
+
+    let mut decoder = builder.build();
+
+    for (_, trace) in result.traces.as_deref_mut().unwrap_or_default() {
+        decoder.identify(trace, &mut identifier);
+    }
+
+    if decode_internal || debug {
+        if let Some(ref etherscan_identifier) = identifier.etherscan {
+            sources.merge(etherscan_identifier.get_compiled_contracts().await?);
+        }
+
+        if debug {
+            let mut debugger = Debugger::builder()
+                .traces(result.traces.expect("missing traces"))
+                .decoder(&decoder)
+                .sources(sources)
+                .build();
+            debugger.try_run_tui()?;
+            return Ok(());
+        }
+
+        decoder.debug_identifier = Some(DebugTraceIdentifier::new(sources));
+    }
+
+    print_traces(&mut result, &decoder, shell::verbosity() > 0, shell::verbosity() > 4).await?;
+
+    Ok(())
+}

crates/cast/src/debug.rs

@@ -58,6 +58,7 @@ pub mod cmd;
 pub mod opts;
 
 pub mod base;
+pub(crate) mod debug;
 pub mod errors;
 mod rlp_converter;
 pub mod tx;

crates/cast/src/lib.rs

@@ -17,7 +17,6 @@ forge-fmt.workspace = true
 foundry-block-explorers.workspace = true
 foundry-common.workspace = true
 foundry-config.workspace = true
-foundry-debugger.workspace = true
 foundry-evm.workspace = true
 foundry-wallets.workspace = true
 

crates/cli/Cargo.toml

@@ -1,33 +1,24 @@
 use alloy_json_abi::JsonAbi;
-use alloy_primitives::{Address, Bytes, map::HashMap};
 use eyre::{Result, WrapErr};
-use foundry_common::{
-    ContractsByArtifact, TestFunctionExt, compile::ProjectCompiler, fs, selectors::SelectorKind,
-    shell,
-};
+use foundry_common::{TestFunctionExt, fs, selectors::SelectorKind, shell};
 use foundry_compilers::{
     Artifact, ArtifactId, ProjectCompileOutput,
     artifacts::{CompactBytecode, Settings},
     cache::{CacheEntry, CompilerCache},
     utils::read_json_file,
 };
 use foundry_config::{Chain, Config, NamedChain, error::ExtractConfigError, figment::Figment};
-use foundry_debugger::Debugger;
 use foundry_evm::{
     executors::{DeployResult, EvmError, RawCallResult},
     opts::EvmOpts,
     traces::{
-        CallTraceDecoder, CallTraceDecoderBuilder, TraceKind, Traces,
-        debug::{ContractSources, DebugTraceIdentifier},
-        decode_trace_arena,
-        identifier::{SignaturesCache, SignaturesIdentifier, TraceIdentifiers},
+        CallTraceDecoder, TraceKind, Traces, decode_trace_arena, identifier::SignaturesCache,
         render_trace_arena_inner,
     },
 };
 use std::{
     fmt::Write,
     path::{Path, PathBuf},
-    str::FromStr,
 };
 use yansi::Paint;
 
@@ -331,85 +322,6 @@ impl TryFrom<Result<RawCallResult>> for TraceResult {
     }
 }
 
-/// labels the traces, conditionally prints them or opens the debugger
-#[expect(clippy::too_many_arguments)]
-pub async fn handle_traces(
-    mut result: TraceResult,
-    config: &Config,
-    chain: Option<Chain>,
-    contracts_bytecode: &HashMap<Address, Bytes>,
-    labels: Vec<String>,
-    with_local_artifacts: bool,
-    debug: bool,
-    decode_internal: bool,
-    disable_label: bool,
-) -> Result<()> {
-    let (known_contracts, mut sources) = if with_local_artifacts {
-        let _ = sh_println!("Compiling project to generate artifacts");
-        let project = config.project()?;
-        let compiler = ProjectCompiler::new();
-        let output = compiler.compile(&project)?;
-        (
-            Some(ContractsByArtifact::new(
-                output.artifact_ids().map(|(id, artifact)| (id, artifact.clone().into())),
-            )),
-            ContractSources::from_project_output(&output, project.root(), None)?,
-        )
-    } else {
-        (None, ContractSources::default())
-    };
-
-    let labels = labels.iter().filter_map(|label_str| {
-        let mut iter = label_str.split(':');
-
-        if let Some(addr) = iter.next()
-            && let (Ok(address), Some(label)) = (Address::from_str(addr), iter.next())
-        {
-            return Some((address, label.to_string()));
-        }
-        None
-    });
-    let config_labels = config.labels.clone().into_iter();
-
-    let mut builder = CallTraceDecoderBuilder::new()
-        .with_labels(labels.chain(config_labels))
-        .with_signature_identifier(SignaturesIdentifier::from_config(config)?)
-        .with_label_disabled(disable_label);
-    let mut identifier = TraceIdentifiers::new().with_etherscan(config, chain)?;
-    if let Some(contracts) = &known_contracts {
-        builder = builder.with_known_contracts(contracts);
-        identifier = identifier.with_local_and_bytecodes(contracts, contracts_bytecode);
-    }
-
-    let mut decoder = builder.build();
-
-    for (_, trace) in result.traces.as_deref_mut().unwrap_or_default() {
-        decoder.identify(trace, &mut identifier);
-    }
-
-    if decode_internal || debug {
-        if let Some(ref etherscan_identifier) = identifier.etherscan {
-            sources.merge(etherscan_identifier.get_compiled_contracts().await?);
-        }
-
-        if debug {
-            let mut debugger = Debugger::builder()
-                .traces(result.traces.expect("missing traces"))
-                .decoder(&decoder)
-                .sources(sources)
-                .build();
-            debugger.try_run_tui()?;
-            return Ok(());
-        }
-
-        decoder.debug_identifier = Some(DebugTraceIdentifier::new(sources));
-    }
-
-    print_traces(&mut result, &decoder, shell::verbosity() > 0, shell::verbosity() > 4).await?;
-
-    Ok(())
-}
-
 pub async fn print_traces(
     result: &mut TraceResult,
     decoder: &CallTraceDecoder,