stratus/eth/executor/

evm.rs

use std::sync::Arc;

use alloy_consensus::transaction::TransactionInfo;
use alloy_rpc_types_trace::geth::CallFrame;
use alloy_rpc_types_trace::geth::FourByteFrame;
use alloy_rpc_types_trace::geth::GethDebugBuiltInTracerType;
use alloy_rpc_types_trace::geth::GethDebugTracerType;
use alloy_rpc_types_trace::geth::GethTrace;
use alloy_rpc_types_trace::geth::NoopFrame;
use alloy_rpc_types_trace::geth::call::FlatCallFrame;
use alloy_rpc_types_trace::geth::mux::MuxFrame;
use anyhow::anyhow;
use itertools::Itertools;
use log::log_enabled;
use revm::Context;
use revm::Database;
use revm::DatabaseRef;
use revm::ExecuteCommitEvm;
use revm::ExecuteEvm;
use revm::InspectEvm;
use revm::Journal;
use revm::context::BlockEnv;
use revm::context::CfgEnv;
use revm::context::Evm as RevmEvm;
use revm::context::TransactTo;
use revm::context::TxEnv;
use revm::context::result::EVMError;
use revm::context::result::ExecutionResult as RevmExecutionResult;
use revm::context::result::InvalidTransaction;
use revm::context::result::ResultAndState;
use revm::database::CacheDB;
use revm::handler::EthFrame;
use revm::handler::EthPrecompiles;
use revm::handler::instructions::EthInstructions;
use revm::interpreter::interpreter::EthInterpreter;
use revm::primitives::B256;
use revm::primitives::U256;
use revm::primitives::hardfork::SpecId;
use revm::state::AccountInfo;
use revm::state::EvmState;
use revm_inspectors::tracing::FourByteInspector;
use revm_inspectors::tracing::MuxInspector;
use revm_inspectors::tracing::TracingInspector;
use revm_inspectors::tracing::TracingInspectorConfig;
use revm_inspectors::tracing::js::JsInspector;

use super::evm_input::InspectorInput;
use crate::alias::RevmAddress;
use crate::alias::RevmBytecode;
use crate::eth::codegen;
use crate::eth::executor::EvmExecutionResult;
use crate::eth::executor::EvmInput;
use crate::eth::executor::ExecutorConfig;
use crate::eth::primitives::Account;
use crate::eth::primitives::Address;
use crate::eth::primitives::BlockFilter;
use crate::eth::primitives::Bytes;
use crate::eth::primitives::EvmExecution;
use crate::eth::primitives::EvmExecutionMetrics;
use crate::eth::primitives::ExecutionAccountChanges;
use crate::eth::primitives::ExecutionChanges;
use crate::eth::primitives::ExecutionResult;
use crate::eth::primitives::Gas;
use crate::eth::primitives::Log;
use crate::eth::primitives::MinedData;
use crate::eth::primitives::PointInTime;
use crate::eth::primitives::Slot;
use crate::eth::primitives::SlotIndex;
use crate::eth::primitives::StorageError;
use crate::eth::primitives::StratusError;
use crate::eth::primitives::TransactionError;
use crate::eth::primitives::TransactionExecution;
use crate::eth::storage::StratusStorage;
use crate::ext::OptionExt;
#[cfg(feature = "metrics")]
use crate::infra::metrics;

/// Maximum gas limit allowed for a transaction. Prevents a transaction from consuming too many resources.
#[cfg(feature = "dev")]
const GAS_MAX_LIMIT: u64 = 1_000_000_000;
#[cfg(not(feature = "dev"))]
const GAS_MAX_LIMIT: u64 = 100_000_000;

type ContextWithDB = Context<BlockEnv, TxEnv, CfgEnv, RevmSession, Journal<RevmSession>>;
type GeneralRevm<DB> =
    RevmEvm<Context<BlockEnv, TxEnv, CfgEnv, DB>, (), EthInstructions<EthInterpreter<()>, Context<BlockEnv, TxEnv, CfgEnv, DB>>, EthPrecompiles, EthFrame>;

/// Implementation of EVM using [`revm`](https://crates.io/crates/revm).
pub struct Evm {
    evm: RevmEvm<ContextWithDB, (), EthInstructions<EthInterpreter, ContextWithDB>, EthPrecompiles, EthFrame>,
    kind: EvmKind,
}

#[derive(Clone, Copy)]
pub enum EvmKind {
    Transaction,
    Call,
}

impl Evm {
    /// Creates a new instance of the Evm.
    pub fn new(storage: Arc<StratusStorage>, config: ExecutorConfig, kind: EvmKind) -> Self {
        tracing::info!(?config, "creating revm");

        // configure revm
        let chain_id = config.executor_chain_id;

        Self {
            evm: Self::create_evm(chain_id, config.executor_evm_spec, RevmSession::new(storage, config.clone()), kind),
            kind,
        }
    }

    /// Execute a transaction that deploys a contract or call a contract function.
    pub fn execute(&mut self, input: EvmInput) -> Result<EvmExecutionResult, StratusError> {
        #[cfg(feature = "metrics")]
        let start = metrics::now();

        // configure session
        self.evm.journaled_state.database.reset(input.clone());

        self.evm.fill_env(input);

        if log_enabled!(log::Level::Debug) {
            let block_env_log = self.evm.block.clone();
            let tx_env_log = self.evm.tx.clone();
            // execute transaction
            tracing::debug!(block_env = ?block_env_log, tx_env = ?tx_env_log, "executing transaction in revm");
        }

        let tx = std::mem::take(&mut self.evm.tx);
        let evm_result = self.evm.transact(tx);

        // extract results
        let session = &mut self.evm.journaled_state.database;
        let session_input = std::mem::take(&mut session.input);
        let session_storage_changes = std::mem::take(&mut session.storage_changes);
        let session_metrics = std::mem::take(&mut session.metrics);
        #[cfg(feature = "metrics")]
        let session_point_in_time = session.input.point_in_time;

        // parse result
        let execution = match evm_result {
            // executed
            Ok(result) => Ok(parse_revm_execution(result, session_input, session_storage_changes)?),

            // nonce errors
            Err(EVMError::Transaction(InvalidTransaction::NonceTooHigh { tx, state })) => Err(TransactionError::Nonce {
                transaction: tx.into(),
                account: state.into(),
            }
            .into()),
            Err(EVMError::Transaction(InvalidTransaction::NonceTooLow { tx, state })) => Err(TransactionError::Nonce {
                transaction: tx.into(),
                account: state.into(),
            }
            .into()),

            // storage error
            Err(EVMError::Database(e)) => {
                tracing::warn!(reason = ?e, "evm storage error");
                Err(e)
            }

            // unexpected errors
            Err(e) => {
                tracing::warn!(reason = ?e, "evm transaction error");
                Err(TransactionError::EvmFailed(e.to_string()).into())
            }
        };

        // track metrics
        #[cfg(feature = "metrics")]
        {
            metrics::inc_evm_execution(start.elapsed(), session_point_in_time, execution.is_ok());
            metrics::inc_evm_execution_account_reads(session_metrics.account_reads);
        }

        execution.map(|execution| EvmExecutionResult {
            execution,
            metrics: session_metrics,
        })
    }

    fn create_evm<DB: Database>(chain_id: u64, spec: SpecId, db: DB, kind: EvmKind) -> GeneralRevm<DB> {
        let ctx = Context::new(db, spec)
            .modify_cfg_chained(|cfg_env| {
                cfg_env.chain_id = chain_id;
                cfg_env.spec = spec;
                cfg_env.tx_chain_id_check = matches!(kind, EvmKind::Transaction);
                cfg_env.limit_contract_initcode_size = None;
                cfg_env.disable_nonce_check = matches!(kind, EvmKind::Call);
                cfg_env.max_blobs_per_tx = None;
                cfg_env.tx_gas_limit_cap = None;
                cfg_env.blob_base_fee_update_fraction = None;
                cfg_env.disable_eip3607 = matches!(kind, EvmKind::Call);
                cfg_env.limit_contract_code_size = Some(usize::MAX);
                cfg_env.memory_limit = (1 << 32) - 1;
                cfg_env.disable_balance_check = false;
                cfg_env.disable_block_gas_limit = false;
                cfg_env.disable_eip3541 = false;
                cfg_env.disable_eip7623 = false;
                cfg_env.disable_base_fee = false;
                cfg_env.disable_fee_charge = false;
            })
            .modify_block_chained(|block_env: &mut BlockEnv| {
                block_env.beneficiary = Address::COINBASE.into();
            })
            .modify_tx_chained(|tx_env: &mut TxEnv| {
                tx_env.gas_priority_fee = None;
            });

        RevmEvm::new(ctx, EthInstructions::new_mainnet(), EthPrecompiles::default())
    }

    /// Execute a transaction using a tracer.
    pub fn inspect(&mut self, input: InspectorInput) -> Result<GethTrace, StratusError> {
        let InspectorInput {
            tx_hash,
            opts,
            trace_unsuccessful_only,
        } = input;
        let tracer_type = opts.tracer.ok_or_else(|| anyhow!("no tracer type provided"))?;

        if matches!(tracer_type, GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::NoopTracer)) {
            return Ok(NoopFrame::default().into());
        }

        let (tx, mined_data): (TransactionExecution, Option<MinedData>) = self
            .evm
            .journaled_state
            .database
            .storage
            .read_transaction(tx_hash)?
            .ok_or_else(|| anyhow!("transaction not found: {tx_hash}"))?
            .into();

        // CREATE transactions need to be traced for blockscout to work correctly
        if tx.result.execution.deployed_contract_address.is_none() && trace_unsuccessful_only && matches!(tx.result.execution.result, ExecutionResult::Success)
        {
            return Ok(default_trace(tracer_type, tx));
        }

        let block = self
            .evm
            .journaled_state
            .database
            .storage
            .read_block(BlockFilter::Number(tx.evm_input.block_number))?
            .ok_or_else(|| {
                StratusError::Storage(StorageError::BlockNotFound {
                    filter: BlockFilter::Number(tx.evm_input.block_number),
                })
            })?;

        let tx_info = TransactionInfo {
            block_hash: Some(block.hash().0.0.into()),
            hash: Some(tx_hash.0.0.into()),
            index: mined_data.map(|data| data.index.into()),
            block_number: Some(block.number().as_u64()),
            base_fee: None,
        };
        let inspect_input: EvmInput = tx.evm_input;
        self.evm.journaled_state.database.reset(EvmInput {
            point_in_time: PointInTime::MinedPast(inspect_input.block_number.prev().unwrap_or_default()),
            ..Default::default()
        });

        let spec = self.evm.cfg.spec;

        let mut cache_db = CacheDB::new(&self.evm.journaled_state.database);
        let mut evm = Self::create_evm(inspect_input.chain_id.unwrap_or_default().into(), spec, &mut cache_db, self.kind);

        // Execute all transactions before target tx_hash
        for tx in block.transactions.into_iter() {
            if tx.info.hash == tx_hash {
                break;
            }
            let tx_input: EvmInput = tx.execution.evm_input;

            // Configure EVM state
            evm.fill_env(tx_input);
            let tx = std::mem::take(&mut evm.tx);
            evm.transact_commit(tx)?;
        }

        let trace_result: GethTrace = match tracer_type {
            GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::FourByteTracer) => {
                let mut inspector = FourByteInspector::default();
                let mut evm_with_inspector = evm.with_inspector(&mut inspector);
                evm_with_inspector.fill_env(inspect_input);
                let tx = std::mem::take(&mut evm_with_inspector.tx);
                evm_with_inspector.inspect_tx(tx)?;
                FourByteFrame::from(&inspector).into()
            }
            GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::CallTracer) => {
                let call_config = opts.tracer_config.into_call_config()?;
                let mut inspector = TracingInspector::new(TracingInspectorConfig::from_geth_call_config(&call_config));
                let mut evm_with_inspector = evm.with_inspector(&mut inspector);
                evm_with_inspector.fill_env(inspect_input);
                let tx = std::mem::take(&mut evm_with_inspector.tx);
                let res = evm_with_inspector.inspect_tx(tx)?;
                let mut trace = inspector.geth_builder().geth_call_traces(call_config, res.result.gas_used()).into();
                enhance_trace_with_decoded_errors(&mut trace);
                trace
            }
            GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::PreStateTracer) => {
                let prestate_config = opts.tracer_config.into_pre_state_config()?;
                let mut inspector = TracingInspector::new(TracingInspectorConfig::from_geth_prestate_config(&prestate_config));
                let mut evm_with_inspector = evm.with_inspector(&mut inspector);
                evm_with_inspector.fill_env(inspect_input);
                let tx = std::mem::take(&mut evm_with_inspector.tx);
                let res = evm_with_inspector.inspect_tx(tx)?;

                inspector.geth_builder().geth_prestate_traces(&res, &prestate_config, &cache_db)?.into()
            }
            GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::NoopTracer) => NoopFrame::default().into(),
            GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::MuxTracer) => {
                let mux_config = opts.tracer_config.into_mux_config()?;
                let mut inspector = MuxInspector::try_from_config(mux_config).map_err(|e| anyhow!(e))?;
                let mut evm_with_inspector = evm.with_inspector(&mut inspector);
                evm_with_inspector.fill_env(inspect_input);
                let tx = std::mem::take(&mut evm_with_inspector.tx);
                let res = evm_with_inspector.inspect_tx(tx)?;
                inspector.try_into_mux_frame(&res, &cache_db, tx_info)?.into()
            }
            GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::FlatCallTracer) => {
                let flat_call_config = opts.tracer_config.into_flat_call_config()?;
                let mut inspector = TracingInspector::new(TracingInspectorConfig::from_flat_call_config(&flat_call_config));
                let mut evm_with_inspector = evm.with_inspector(&mut inspector);
                evm_with_inspector.fill_env(inspect_input);
                let tx = std::mem::take(&mut evm_with_inspector.tx);
                let res = evm_with_inspector.inspect_tx(tx)?;
                inspector
                    .with_transaction_gas_limit(res.result.gas_used())
                    .into_parity_builder()
                    .into_localized_transaction_traces(tx_info)
                    .into()
            }
            GethDebugTracerType::JsTracer(code) => {
                let mut inspector = JsInspector::new(code, opts.tracer_config.into_json()).map_err(|e| anyhow!(e.to_string()))?;
                let mut evm_with_inspector = evm.with_inspector(&mut inspector);
                evm_with_inspector.fill_env(inspect_input);
                let tx = std::mem::take(&mut evm_with_inspector.tx);
                let block = std::mem::take(&mut evm_with_inspector.block);
                let res = evm_with_inspector.inspect_tx(tx.clone())?;
                GethTrace::JS(inspector.json_result(res, &tx, &block, &cache_db).map_err(|e| anyhow!(e.to_string()))?)
            }
        };

        Ok(trace_result)
    }
}

trait TxEnvExt {
    fn fill_env(&mut self, input: EvmInput);
}

trait EvmExt<DB: Database> {
    fn fill_env(&mut self, input: EvmInput);
}

impl<DB: Database, INSP, I, P, F> EvmExt<DB> for RevmEvm<Context<BlockEnv, TxEnv, CfgEnv, DB>, INSP, I, P, F> {
    fn fill_env(&mut self, input: EvmInput) {
        self.block.fill_env(&input);
        self.tx.fill_env(input);
    }
}

impl TxEnvExt for TxEnv {
    fn fill_env(&mut self, input: EvmInput) {
        self.caller = input.from.into();
        self.kind = match input.to {
            Some(contract) => TransactTo::Call(contract.into()),
            None => TransactTo::Create,
        };
        self.gas_limit = GAS_MAX_LIMIT;
        self.gas_price = 0;
        self.chain_id = input.chain_id.map_into();
        self.nonce = input.nonce.map_into().unwrap_or_default();
        self.data = input.data.into();
        self.value = input.value.into();
        self.gas_priority_fee = None;
    }
}

trait BlockEnvExt {
    fn fill_env(&mut self, input: &EvmInput);
}

impl BlockEnvExt for BlockEnv {
    fn fill_env(&mut self, input: &EvmInput) {
        self.timestamp = U256::from(*input.block_timestamp);
        self.number = U256::from(input.block_number.as_u64());
        self.basefee = 0;
    }
}

// -----------------------------------------------------------------------------
// Database
// -----------------------------------------------------------------------------

/// Contextual data that is read or set durint the execution of a transaction in the EVM.
struct RevmSession {
    /// Executor configuration.
    config: ExecutorConfig,

    /// Service to communicate with the storage.
    storage: Arc<StratusStorage>,

    /// Input passed to EVM to execute the transaction.
    input: EvmInput,

    /// Changes made to the storage during the execution of the transaction.
    storage_changes: ExecutionChanges,

    /// Metrics collected during EVM execution.
    metrics: EvmExecutionMetrics,
}

impl RevmSession {
    /// Creates the base session to be used with REVM.
    pub fn new(storage: Arc<StratusStorage>, config: ExecutorConfig) -> Self {
        Self {
            config,
            storage,
            input: EvmInput::default(),
            storage_changes: ExecutionChanges::default(),
            metrics: EvmExecutionMetrics::default(),
        }
    }

    /// Resets the session to be used with a new transaction.
    pub fn reset(&mut self, input: EvmInput) {
        self.input = input;
        self.storage_changes = ExecutionChanges::default();
        self.metrics = EvmExecutionMetrics::default();
    }
}

impl Database for RevmSession {
    type Error = StratusError;

    fn basic(&mut self, revm_address: RevmAddress) -> Result<Option<AccountInfo>, StratusError> {
        self.metrics.account_reads += 1;

        // retrieve account
        let address: Address = revm_address.into();
        let account = self.storage.read_account(address, self.input.point_in_time, self.input.kind)?;

        // warn if the loaded account is the `to` account and it does not have a bytecode
        if let Some(to_address) = self.input.to
            && account.bytecode.is_none()
            && address == to_address
            && self.input.is_contract_call()
        {
            if self.config.executor_reject_not_contract {
                return Err(TransactionError::AccountNotContract { address: to_address }.into());
            } else {
                tracing::warn!(%address, "evm to_account is not a contract because does not have bytecode");
            }
        }

        if !address.is_ignored()
            && let std::collections::hash_map::Entry::Vacant(entry) = self.storage_changes.accounts.entry(address)
        {
            entry.insert(ExecutionAccountChanges::from_unchanged(account.clone()));
        }

        Ok(Some(account.into()))
    }

    fn code_by_hash(&mut self, _: B256) -> Result<RevmBytecode, StratusError> {
        todo!()
    }

    fn storage(&mut self, revm_address: RevmAddress, revm_index: U256) -> Result<U256, StratusError> {
        self.metrics.slot_reads += 1;

        // convert slot
        let address: Address = revm_address.into();
        let index: SlotIndex = revm_index.into();

        // load slot from storage
        let slot = self.storage.read_slot(address, index, self.input.point_in_time, self.input.kind)?;

        Ok(slot.value.into())
    }

    fn block_hash(&mut self, _: u64) -> Result<B256, StratusError> {
        todo!()
    }
}

impl DatabaseRef for RevmSession {
    type Error = StratusError;

    fn basic_ref(&self, address: revm::primitives::Address) -> Result<Option<AccountInfo>, Self::Error> {
        // retrieve account
        let address: Address = address.into();
        let account = self.storage.read_account(address, self.input.point_in_time, self.input.kind)?;
        Ok(Some(account.into()))
    }

    fn storage_ref(&self, address: revm::primitives::Address, index: U256) -> Result<U256, Self::Error> {
        // convert slot
        let address: Address = address.into();
        let index: SlotIndex = index.into();

        // load slot from storage
        let slot = self.storage.read_slot(address, index, self.input.point_in_time, self.input.kind)?;

        Ok(slot.value.into())
    }

    fn block_hash_ref(&self, _: u64) -> Result<B256, Self::Error> {
        todo!()
    }

    fn code_by_hash_ref(&self, _code_hash: B256) -> Result<revm::state::Bytecode, Self::Error> {
        unimplemented!()
    }
}

// -----------------------------------------------------------------------------
// Conversion
// -----------------------------------------------------------------------------

fn parse_revm_execution(revm_result: ResultAndState, input: EvmInput, execution_changes: ExecutionChanges) -> Result<EvmExecution, StratusError> {
    let (result, tx_output, logs, gas) = parse_revm_result(revm_result.result);
    let (changes, deployed_contract_address) = parse_revm_state(revm_result.state, execution_changes)?;
    tracing::debug!(?result, %gas, tx_output_len = %tx_output.len(), %tx_output, "evm executed");

    Ok(EvmExecution {
        block_timestamp: input.block_timestamp,
        result,
        output: tx_output,
        logs,
        gas_used: gas,
        changes,
        deployed_contract_address,
    })
}

fn parse_revm_result(result: RevmExecutionResult) -> (ExecutionResult, Bytes, Vec<Log>, Gas) {
    match result {
        RevmExecutionResult::Success { output, gas_used, logs, .. } => {
            let result = ExecutionResult::Success;
            let output = Bytes::from(output);
            let logs = logs.into_iter().map_into().collect();
            let gas = Gas::from(gas_used);
            (result, output, logs, gas)
        }
        RevmExecutionResult::Revert { output, gas_used } => {
            let output = Bytes::from(output);
            let result = ExecutionResult::Reverted { reason: (&output).into() };
            let gas = Gas::from(gas_used);
            (result, output, Vec::new(), gas)
        }
        RevmExecutionResult::Halt { reason, gas_used } => {
            let result = ExecutionResult::new_halted(format!("{reason:?}"));
            let output = Bytes::default();
            let gas = Gas::from(gas_used);
            (result, output, Vec::new(), gas)
        }
    }
}

fn parse_revm_state(revm_state: EvmState, mut execution_changes: ExecutionChanges) -> Result<(ExecutionChanges, Option<Address>), StratusError> {
    let mut deployed_contract_address = None;

    for (revm_address, revm_account) in revm_state {
        let address: Address = revm_address.into();
        if address.is_ignored() {
            continue;
        }

        // apply changes according to account status
        tracing::debug!(
            %address,
            status = ?revm_account.status,
            balance = %revm_account.info.balance,
            nonce = %revm_account.info.nonce,
            slots = %revm_account.storage.len(),
            "evm account"
        );

        let (account_created, account_touched) = (revm_account.is_created(), revm_account.is_touched());

        if !(account_created || account_touched) {
            continue;
        }

        // parse revm types to stratus primitives
        let account: Account = (revm_address, revm_account.info).into();
        let account_modified_slots: Vec<Slot> = revm_account
            .storage
            .into_iter()
            .filter_map(|(index, value)| match value.is_changed() {
                true => Some(Slot::new(index.into(), value.present_value.into())),
                false => None,
            })
            .collect();

        if account_created && account.bytecode.is_some() {
            deployed_contract_address = Some(account.address);
        }

        execution_changes.insert(account, account_modified_slots);
    }
    Ok((execution_changes, deployed_contract_address))
}

pub fn default_trace(tracer_type: GethDebugTracerType, tx: TransactionExecution) -> GethTrace {
    match tracer_type {
        GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::FourByteTracer) => FourByteFrame::default().into(),
        // HACK: Spoof empty call frame to prevent Blockscout from retrying unnecessary trace calls
        GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::CallTracer) => {
            let (typ, to) = match tx.evm_input.to {
                Some(_) => ("CALL".to_string(), tx.evm_input.to.map_into()),
                None => ("CREATE".to_string(), tx.result.execution.deployed_contract_address.map_into()),
            };

            CallFrame {
                from: tx.evm_input.from.into(),
                to,
                typ,
                ..Default::default()
            }
            .into()
        }
        GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::MuxTracer) => MuxFrame::default().into(),
        GethDebugTracerType::BuiltInTracer(GethDebugBuiltInTracerType::FlatCallTracer) => FlatCallFrame::default().into(),
        _ => NoopFrame::default().into(),
    }
}

/// Enhances a GethTrace with decoded error information.
fn enhance_trace_with_decoded_errors(trace: &mut GethTrace) {
    match trace {
        GethTrace::CallTracer(call_frame) => {
            enhance_call_frame_errors(call_frame);
        }
        _ => {
            // Other trace types don't have call frames with errors to decode
        }
    }
}

/// Enhances a single CallFrame and recursively enhances all nested calls.
fn enhance_call_frame_errors(frame: &mut CallFrame) {
    if let Some(error) = frame.error.as_ref()
        && let Some(decoded_error) = frame.output.as_ref().and_then(|output| codegen::error_sig_opt(output))
    {
        frame.revert_reason = Some(format!("{error}: {decoded_error}"));
    }

    for nested_call in frame.calls.iter_mut() {
        enhance_call_frame_errors(nested_call);
    }
}