[feat] cast call --trace (& code reuse in cast run) (foundry-rs#5477)

* initial start

* traces working

* Update opts.rs

* clean up

* comments/debugger

* comment

* change build -> fill

* start of move to evm crate

* rename

* put fork setup on tracing executor

* comment

* return err on no traces

* moving trace handlers to cast::cmd::utils

* rm formatting

* fmt

* use a ref

* fix unneeded borrow

* unused import

* panic instead of bail

* initial

* Update cli/src/cmd/cast/call.rs

Co-authored-by: evalir <[email protected]>

* Update cli/src/cmd/utils.rs

Co-authored-by: evalir <[email protected]>

* Update cli/src/cmd/utils.rs

Co-authored-by: evalir <[email protected]>

* Update evm/src/trace/mod.rs

Co-authored-by: evalir <[email protected]>

* comment

* unresolve convo

* TraceResult::from

* clippy --fix

* use from/try_from

* clippy --fix

* clean up, no extra url in panic

* formatting

* fix imports

* fix clap rxequirements

* Update cli/src/cmd/cast/call.rs

* cargo fmt

* move tracing executor to its own file

---------

Co-authored-by: N <[email protected]>
Co-authored-by: evalir <[email protected]>

Author: 3 people

cli/src/cmd/cast/call.rs

@@ -1,15 +1,24 @@
 // cast estimate subcommands
 use crate::{
+    cmd::utils::{handle_traces, TraceResult},
     opts::{EthereumOpts, TransactionOpts},
     utils::{self, parse_ether_value},
 };
 use cast::{Cast, TxBuilder};
 use clap::Parser;
-use ethers::types::{BlockId, NameOrAddress, U256};
+use ethers::{
+    solc::EvmVersion,
+    types::{BlockId, NameOrAddress, U256},
+};
 use eyre::WrapErr;
-use foundry_config::Config;
+use forge::executor::opts::EvmOpts;
+use foundry_config::{find_project_root_path, Config};
+use foundry_evm::trace::TracingExecutor;
 use std::str::FromStr;
 
+type Provider =
+    ethers::providers::Provider<ethers::providers::RetryClient<ethers::providers::Http>>;
+
 /// CLI arguments for `cast call`.
 #[derive(Debug, Parser)]
 pub struct CallArgs {
@@ -31,13 +40,41 @@ pub struct CallArgs {
     )]
     data: Option<String>,
 
+    /// Forks the remote rpc, executes the transaction locally and prints a trace
+    #[clap(long, default_value_t = false)]
+    trace: bool,
+
+    /// Can only be used with "--trace"
+    ///
+    /// opens an interactive debugger
+    #[clap(long, requires = "trace")]
+    debug: bool,
+
+    /// Can only be used with "--trace"
+    ///
+    /// prints a more verbose trace
+    #[clap(long, requires = "trace")]
+    verbose: bool,
+
+    /// Can only be used with "--trace"
+    /// Labels to apply to the traces.
+    ///
+    /// Format: `address:label`
+    #[clap(long, requires = "trace")]
+    labels: Vec<String>,
+
+    /// Can only be used with "--trace"
+    ///
+    /// The EVM Version to use.
+    #[clap(long, requires = "trace")]
+    evm_version: Option<EvmVersion>,
+
     /// The block height to query at.
     ///
     /// Can also be the tags earliest, finalized, safe, latest, or pending.
     #[clap(long, short)]
     block: Option<BlockId>,
 
-    /// Simulate a contract deployment.
     #[clap(subcommand)]
     command: Option<CallSubcommands>,
 
@@ -50,6 +87,7 @@ pub struct CallArgs {
 
 #[derive(Debug, Parser)]
 pub enum CallSubcommands {
+    /// ignores the address field and simulates creating a contract
     #[clap(name = "--create")]
     Create {
         /// Bytecode of contract.
@@ -73,54 +111,158 @@ pub enum CallSubcommands {
 
 impl CallArgs {
     pub async fn run(self) -> eyre::Result<()> {
-        let CallArgs { to, sig, args, data, tx, eth, command, block } = self;
+        let CallArgs {
+            to,
+            sig,
+            args,
+            data,
+            tx,
+            eth,
+            command,
+            block,
+            trace,
+            evm_version,
+            debug,
+            verbose,
+            labels,
+        } = self;
 
         let config = Config::from(&eth);
         let provider = utils::get_provider(&config)?;
         let chain = utils::get_chain(config.chain_id, &provider).await?;
         let sender = eth.wallet.sender().await;
 
-        let mut builder = TxBuilder::new(&provider, sender, to, chain, tx.legacy).await?;
+        let mut builder: TxBuilder<'_, Provider> =
+            TxBuilder::new(&provider, sender, to, chain, tx.legacy).await?;
+
         builder
             .gas(tx.gas_limit)
             .etherscan_api_key(config.get_etherscan_api_key(Some(chain)))
             .gas_price(tx.gas_price)
             .priority_gas_price(tx.priority_gas_price)
             .nonce(tx.nonce);
+
         match command {
             Some(CallSubcommands::Create { code, sig, args, value }) => {
-                builder.value(value);
+                if trace {
+                    let figment = Config::figment_with_root(find_project_root_path(None).unwrap())
+                        .merge(eth.rpc);
+
+                    let evm_opts = figment.extract::<EvmOpts>()?;
+
+                    let (env, fork, chain) =
+                        TracingExecutor::get_fork_material(&config, evm_opts).await?;
 
-                let mut data = hex::decode(code.strip_prefix("0x").unwrap_or(&code))?;
+                    let mut executor =
+                        foundry_evm::trace::TracingExecutor::new(env, fork, evm_version, debug)
+                            .await;
 
-                if let Some(s) = sig {
-                    let (mut sigdata, _func) = builder.create_args(&s, args).await?;
-                    data.append(&mut sigdata);
+                    let trace = match executor.deploy(
+                        sender,
+                        code.into(),
+                        value.unwrap_or(U256::zero()),
+                        None,
+                    ) {
+                        Ok(deploy_result) => TraceResult::from(deploy_result),
+                        Err(evm_err) => TraceResult::try_from(evm_err)?,
+                    };
+
+                    handle_traces(trace, &config, chain, labels, verbose, debug).await?;
+
+                    return Ok(())
                 }
 
-                builder.set_data(data);
+                // fill the builder after the conditional so we dont move values
+                fill_create(&mut builder, value, code, sig, args).await?;
             }
             _ => {
-                builder.value(tx.value);
+                // fill first here because we need to use the builder in the conditional
+                fill_tx(&mut builder, tx.value, sig, args, data).await?;
 
-                if let Some(sig) = sig {
-                    builder.set_args(sig.as_str(), args).await?;
-                }
-                if let Some(data) = data {
-                    // Note: `sig+args` and `data` are mutually exclusive
-                    builder.set_data(
-                        hex::decode(data).wrap_err("Expected hex encoded function data")?,
-                    );
+                if trace {
+                    let figment = Config::figment_with_root(find_project_root_path(None).unwrap())
+                        .merge(eth.rpc);
+
+                    let evm_opts = figment.extract::<EvmOpts>()?;
+
+                    let (env, fork, chain) =
+                        TracingExecutor::get_fork_material(&config, evm_opts).await?;
+
+                    let mut executor =
+                        foundry_evm::trace::TracingExecutor::new(env, fork, evm_version, debug)
+                            .await;
+
+                    let (tx, _) = builder.build();
+
+                    let trace = TraceResult::from(executor.call_raw_committing(
+                        sender,
+                        tx.to_addr().copied().expect("an address to be here"),
+                        tx.data().cloned().unwrap_or_default().to_vec().into(),
+                        tx.value().copied().unwrap_or_default(),
+                    )?);
+
+                    handle_traces(trace, &config, chain, labels, verbose, debug).await?;
+
+                    return Ok(())
                 }
             }
         };
 
-        let builder_output = builder.build();
+        let builder_output: (
+            ethers::types::transaction::eip2718::TypedTransaction,
+            Option<ethers::abi::Function>,
+        ) = builder.build();
+
         println!("{}", Cast::new(provider).call(builder_output, block).await?);
+
         Ok(())
     }
 }
 
+/// fills the builder from create arg
+async fn fill_create(
+    builder: &mut TxBuilder<'_, Provider>,
+    value: Option<U256>,
+    code: String,
+    sig: Option<String>,
+    args: Vec<String>,
+) -> eyre::Result<()> {
+    builder.value(value);
+
+    let mut data = hex::decode(code.strip_prefix("0x").unwrap_or(&code))?;
+
+    if let Some(s) = sig {
+        let (mut sigdata, _func) = builder.create_args(&s, args).await?;
+        data.append(&mut sigdata);
+    }
+
+    builder.set_data(data);
+
+    Ok(())
+}
+
+/// fills the builder from args
+async fn fill_tx(
+    builder: &mut TxBuilder<'_, Provider>,
+    value: Option<U256>,
+    sig: Option<String>,
+    args: Vec<String>,
+    data: Option<String>,
+) -> eyre::Result<()> {
+    builder.value(value);
+
+    if let Some(sig) = sig {
+        builder.set_args(sig.as_str(), args).await?;
+    }
+
+    if let Some(data) = data {
+        // Note: `sig+args` and `data` are mutually exclusive
+        builder.set_data(hex::decode(data).wrap_err("Expected hex encoded function data")?);
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;