@nomicfoundation/edr 0.6.5 → 0.7.0

package/src/trace/mapped_inlined_internal_functions_heuristics.rs

@@ -1,180 +0,0 @@
-//!  This file includes Solidity tracing heuristics for solc starting with
-//! version  0.6.9.
-//!
-//!  This solc version introduced a significant change to how sourcemaps are
-//!  handled for inline yul/internal functions. These were mapped to the
-//!  unmapped/-1 file before, which lead to many unmapped reverts. Now, they are
-//!  mapped to the part of the Solidity source that lead to their inlining.
-//!
-//!  This change is a very positive change, as errors would point to the correct
-//!  line by default. The only problem is that we used to rely very heavily on
-//!  unmapped reverts to decide when our error detection heuristics were to be
-//!  run. In fact, these heuristics were first introduced because of unmapped
-//!  reverts.
-//!
-//!  Instead of synthetically completing stack traces when unmapped reverts
-//! occur, we now start from complete stack traces and adjust them if we can
-//! provide more meaningful errors.
-
-use edr_evm::interpreter::OpCode;
-use napi::{
-    bindgen_prelude::{Either24, Either4},
-    Either,
-};
-use semver::Version;
-
-use super::{
-    message_trace::{CallMessageTrace, CreateMessageTrace, EvmStep},
-    solidity_stack_trace::{
-        InvalidParamsErrorStackTraceEntry, NonContractAccountCalledErrorStackTraceEntry,
-        RevertErrorStackTraceEntry, SolidityStackTrace, StackTraceEntryTypeConst,
-    },
-};
-
-const FIRST_SOLC_VERSION_WITH_MAPPED_SMALL_INTERNAL_FUNCTIONS: Version = Version::new(0, 6, 9);
-
-pub fn stack_trace_may_require_adjustments(
-    stacktrace: &SolidityStackTrace,
-    decoded_trace: Either<&CallMessageTrace, &CreateMessageTrace>,
-) -> bool {
-    let bytecode = match &decoded_trace {
-        Either::A(create) => &create.bytecode,
-        Either::B(call) => &call.bytecode,
-    };
-    let bytecode = bytecode.as_ref().expect("JS code asserts");
-
-    let Some(last_frame) = stacktrace.last() else {
-        return false;
-    };
-
-    if let Either24::E(last_frame @ RevertErrorStackTraceEntry { .. }) = last_frame {
-        return !last_frame.is_invalid_opcode_error
-            && last_frame.return_data.is_empty()
-            && Version::parse(&bytecode.compiler_version)
-                .map(|version| version >= FIRST_SOLC_VERSION_WITH_MAPPED_SMALL_INTERNAL_FUNCTIONS)
-                .unwrap_or(false);
-    }
-
-    false
-}
-
-pub fn adjust_stack_trace(
-    mut stacktrace: SolidityStackTrace,
-    decoded_trace: Either<&CallMessageTrace, &CreateMessageTrace>,
-) -> napi::Result<SolidityStackTrace> {
-    let Some(Either24::E(revert @ RevertErrorStackTraceEntry { .. })) = stacktrace.last() else {
-        unreachable!("JS code asserts that; it's only used immediately after we check with `stack_trace_may_require_adjustments` that the last frame is a revert frame");
-    };
-
-    // Replace the last revert frame with an adjusted frame if needed
-    if is_non_contract_account_called_error(decoded_trace)? {
-        let last_revert_frame_source_reference = revert.source_reference.clone();
-        stacktrace.pop();
-        stacktrace.push(
-            NonContractAccountCalledErrorStackTraceEntry {
-                type_: StackTraceEntryTypeConst,
-                source_reference: last_revert_frame_source_reference,
-            }
-            .into(),
-        );
-        return Ok(stacktrace);
-    }
-
-    if is_constructor_invalid_params_error(decoded_trace)? {
-        let last_revert_frame_source_reference = revert.source_reference.clone();
-        stacktrace.pop();
-        stacktrace.push(
-            InvalidParamsErrorStackTraceEntry {
-                type_: StackTraceEntryTypeConst,
-                source_reference: last_revert_frame_source_reference,
-            }
-            .into(),
-        );
-        return Ok(stacktrace);
-    }
-
-    if is_call_invalid_params_error(decoded_trace)? {
-        let last_revert_frame_source_reference = revert.source_reference.clone();
-        stacktrace.pop();
-        stacktrace.push(
-            InvalidParamsErrorStackTraceEntry {
-                type_: StackTraceEntryTypeConst,
-                source_reference: last_revert_frame_source_reference,
-            }
-            .into(),
-        );
-
-        return Ok(stacktrace);
-    }
-
-    Ok(stacktrace)
-}
-
-fn is_non_contract_account_called_error(
-    decoded_trace: Either<&CallMessageTrace, &CreateMessageTrace>,
-) -> napi::Result<bool> {
-    match_opcodes(
-        decoded_trace,
-        -9,
-        &[
-            OpCode::EXTCODESIZE,
-            OpCode::ISZERO,
-            OpCode::DUP1,
-            OpCode::ISZERO,
-        ],
-    )
-}
-
-fn is_constructor_invalid_params_error(
-    decoded_trace: Either<&CallMessageTrace, &CreateMessageTrace>,
-) -> napi::Result<bool> {
-    Ok(match_opcodes(decoded_trace, -20, &[OpCode::CODESIZE])?
-        && match_opcodes(decoded_trace, -15, &[OpCode::CODECOPY])?
-        && match_opcodes(decoded_trace, -7, &[OpCode::LT, OpCode::ISZERO])?)
-}
-
-fn is_call_invalid_params_error(
-    decoded_trace: Either<&CallMessageTrace, &CreateMessageTrace>,
-) -> napi::Result<bool> {
-    Ok(match_opcodes(decoded_trace, -11, &[OpCode::CALLDATASIZE])?
-        && match_opcodes(decoded_trace, -7, &[OpCode::LT, OpCode::ISZERO])?)
-}
-
-fn match_opcodes(
-    decoded_trace: Either<&CallMessageTrace, &CreateMessageTrace>,
-    first_step_index: i32,
-    opcodes: &[OpCode],
-) -> napi::Result<bool> {
-    let (bytecode, steps) = match &decoded_trace {
-        Either::A(call) => (&call.bytecode, &call.steps),
-        Either::B(create) => (&create.bytecode, &create.steps),
-    };
-    let bytecode = bytecode.as_ref().expect("JS code asserts");
-
-    // If the index is negative, we start from the end of the trace,
-    // just like in the original JS code
-    let mut index = match first_step_index {
-        0.. => first_step_index as usize,
-        ..=-1 if first_step_index.abs() < steps.len() as i32 => {
-            (steps.len() as i32 + first_step_index) as usize
-        }
-        // Out of bounds
-        _ => return Ok(false),
-    };
-
-    for opcode in opcodes {
-        let Some(Either4::A(EvmStep { pc })) = steps.get(index) else {
-            return Ok(false);
-        };
-
-        let instruction = bytecode.get_instruction(*pc)?;
-
-        if instruction.opcode != *opcode {
-            return Ok(false);
-        }
-
-        index += 1;
-    }
-
-    Ok(true)
-}

package/src/trace/message_trace.rs

@@ -1,179 +0,0 @@
-//! Bridging type for the existing `MessageTrace` interface in Hardhat.
-
-use napi::{
-    bindgen_prelude::{BigInt, ClassInstance, Either3, Either4, Uint8Array, Undefined},
-    Either, Env,
-};
-use napi_derive::napi;
-
-use super::{exit::Exit, model::BytecodeWrapper};
-
-#[napi(object)]
-pub struct EvmStep {
-    pub pc: u32,
-}
-
-#[napi(object)]
-pub struct PrecompileMessageTrace {
-    // `BaseMessageTrace`
-    pub value: BigInt,
-    pub return_data: Uint8Array,
-    pub exit: ClassInstance<Exit>,
-    pub gas_used: BigInt,
-    pub depth: u32,
-    // `PrecompileMessageTrace`
-    pub precompile: u32,
-    pub calldata: Uint8Array,
-}
-
-// NOTE: Because of the hack below for `deployed_contract`, now the
-// `CallMessageTrace` is a strict superset of `CreateMessageTrace`, so we need
-// to take care to keep the order consistent from most-specific to
-// least-specific in the `Either{3,4}` type when converting to or from N-API.
-#[napi(object)]
-pub struct CreateMessageTrace {
-    // `BaseMessageTrace`
-    pub value: BigInt,
-    pub return_data: Uint8Array,
-    pub exit: ClassInstance<Exit>,
-    pub gas_used: BigInt,
-    pub depth: u32,
-    // `BaseEvmMessageTrace`
-    pub code: Uint8Array,
-    pub steps: Vec<Either4<EvmStep, PrecompileMessageTrace, CallMessageTrace, CreateMessageTrace>>,
-    /// Reference to the resolved `Bytecode` EDR data.
-    /// Only used on the JS side by the `VmTraceDecoder` class.
-    pub bytecode: Option<ClassInstance<BytecodeWrapper>>,
-    pub number_of_subtraces: u32,
-    // `CreateMessageTrace`
-    // HACK: It seems that `Either<Uint8Array, Undefined>` means exactly what we
-    // want (a required property but can be explicitly `undefined`) but internally
-    // the napi-rs treats an encountered `Undefined` like a missing property
-    // and it throws a validation error. While not 100% backwards compatible, we
-    // work around using an optional type.
-    // See https://github.com/napi-rs/napi-rs/issues/1986 for context on the PR
-    // that introduced this behavior.
-    pub deployed_contract: Option<Either<Uint8Array, Undefined>>,
-}
-
-#[napi(object)]
-pub struct CallMessageTrace {
-    // `BaseMessageTrace`
-    pub value: BigInt,
-    pub return_data: Uint8Array,
-    pub exit: ClassInstance<Exit>,
-    pub gas_used: BigInt,
-    pub depth: u32,
-    // `BaseEvmMessageTrace`
-    pub code: Uint8Array,
-    pub steps: Vec<Either4<EvmStep, PrecompileMessageTrace, CallMessageTrace, CreateMessageTrace>>,
-    /// Reference to the resolved `Bytecode` EDR data.
-    /// Only used on the JS side by the `VmTraceDecoder` class.
-    pub bytecode: Option<ClassInstance<BytecodeWrapper>>,
-    pub number_of_subtraces: u32,
-    // `CallMessageTrace`
-    pub calldata: Uint8Array,
-    pub address: Uint8Array,
-    pub code_address: Uint8Array,
-}
-
-/// Converts [`edr_solidity::message_trace::MessageTraceStep`] to the N-API
-/// representation.
-///
-/// # Panics
-/// This function will panic if the value is mutably borrowed.
-pub fn message_trace_step_to_napi(
-    value: edr_solidity::message_trace::MessageTraceStep,
-    env: Env,
-) -> napi::Result<Either4<EvmStep, PrecompileMessageTrace, CallMessageTrace, CreateMessageTrace>> {
-    Ok(match value {
-        edr_solidity::message_trace::MessageTraceStep::Evm(step) => {
-            Either4::A(EvmStep { pc: step.pc as u32 })
-        }
-        edr_solidity::message_trace::MessageTraceStep::Message(msg) => {
-            // Immediately drop the borrow lock to err on the safe side as we
-            // may be recursing.
-            let owned = msg.borrow().clone();
-            match message_trace_to_napi(owned, env)? {
-                Either3::A(precompile) => Either4::B(precompile),
-                Either3::B(call) => Either4::C(call),
-                Either3::C(create) => Either4::D(create),
-            }
-        }
-    })
-}
-
-/// Converts the Rust representation of a `MessageTrace` to the N-API
-/// representation.
-pub fn message_trace_to_napi(
-    value: edr_solidity::message_trace::MessageTrace,
-    env: Env,
-) -> napi::Result<Either3<PrecompileMessageTrace, CallMessageTrace, CreateMessageTrace>> {
-    Ok(match value {
-        edr_solidity::message_trace::MessageTrace::Precompile(precompile) => {
-            Either3::A(PrecompileMessageTrace {
-                value: BigInt {
-                    sign_bit: false,
-                    words: precompile.base.value.as_limbs().to_vec(),
-                },
-                return_data: Uint8Array::from(precompile.base.return_data.as_ref()),
-                exit: Exit(precompile.base.exit.into()).into_instance(env)?,
-                gas_used: BigInt::from(precompile.base.gas_used),
-                depth: precompile.base.depth as u32,
-
-                precompile: precompile.precompile,
-                calldata: Uint8Array::from(precompile.calldata.as_ref()),
-            })
-        }
-        edr_solidity::message_trace::MessageTrace::Call(call) => Either3::B(CallMessageTrace {
-            value: BigInt {
-                sign_bit: false,
-                words: call.base.base.value.as_limbs().to_vec(),
-            },
-            return_data: Uint8Array::from(call.base.base.return_data.as_ref()),
-            exit: Exit(call.base.base.exit.into()).into_instance(env)?,
-            gas_used: BigInt::from(call.base.base.gas_used),
-            depth: call.base.base.depth as u32,
-            code: Uint8Array::from(call.base.code.as_ref()),
-            steps: call
-                .base
-                .steps
-                .into_iter()
-                .map(|step| message_trace_step_to_napi(step, env))
-                .collect::<napi::Result<Vec<_>>>()?,
-            // NOTE: We specifically use None as that will be later filled on the JS side
-            bytecode: None,
-            number_of_subtraces: call.base.number_of_subtraces,
-
-            address: Uint8Array::from(call.address.as_slice()),
-            calldata: Uint8Array::from(call.calldata.as_ref()),
-            code_address: Uint8Array::from(call.code_address.as_slice()),
-        }),
-        edr_solidity::message_trace::MessageTrace::Create(create) => {
-            Either3::C(CreateMessageTrace {
-                value: BigInt {
-                    sign_bit: false,
-                    words: create.base.base.value.as_limbs().to_vec(),
-                },
-                return_data: Uint8Array::from(create.base.base.return_data.as_ref()),
-                exit: Exit(create.base.base.exit.into()).into_instance(env)?,
-                gas_used: BigInt::from(create.base.base.gas_used),
-                depth: create.base.base.depth as u32,
-                code: Uint8Array::from(create.base.code.as_ref()),
-                steps: create
-                    .base
-                    .steps
-                    .into_iter()
-                    .map(|step| message_trace_step_to_napi(step, env))
-                    .collect::<napi::Result<Vec<_>>>()?,
-                // NOTE: We specifically use None as that will be later filled on the JS side
-                bytecode: None,
-
-                number_of_subtraces: create.base.number_of_subtraces,
-                deployed_contract: create
-                    .deployed_contract
-                    .map(|contract| Either::A(Uint8Array::from(contract.as_ref()))),
-            })
-        }
-    })
-}

package/src/trace/solidity_tracer.rs

@@ -1,315 +0,0 @@
-use edr_evm::interpreter::OpCode;
-use edr_solidity::build_model::{Instruction, JumpType};
-use napi::{
-    bindgen_prelude::{Either3, Either4},
-    Either,
-};
-use napi_derive::napi;
-
-use super::{
-    error_inferrer::{
-        instruction_to_callstack_stack_trace_entry, ErrorInferrer, SubmessageDataRef,
-    },
-    mapped_inlined_internal_functions_heuristics::{
-        adjust_stack_trace, stack_trace_may_require_adjustments,
-    },
-    message_trace::{CallMessageTrace, CreateMessageTrace, EvmStep, PrecompileMessageTrace},
-    solidity_stack_trace::{PrecompileErrorStackTraceEntry, SolidityStackTrace},
-};
-use crate::trace::{
-    exit::ExitCode,
-    solidity_stack_trace::{
-        ContractTooLargeErrorStackTraceEntry, SolidityStackTraceEntry, StackTraceEntryTypeConst,
-        UnrecognizedContractCallstackEntryStackTraceEntry,
-        UnrecognizedContractErrorStackTraceEntry, UnrecognizedCreateCallstackEntryStackTraceEntry,
-        UnrecognizedCreateErrorStackTraceEntry,
-    },
-};
-
-#[napi(constructor)]
-pub struct SolidityTracer;
-
-#[allow(clippy::unused_self)] // we allow this for convenience for now
-#[napi]
-impl SolidityTracer {
-    #[napi(catch_unwind)]
-    pub fn get_stack_trace(
-        &self,
-        trace: Either3<PrecompileMessageTrace, CallMessageTrace, CreateMessageTrace>,
-    ) -> napi::Result<SolidityStackTrace> {
-        let trace = match &trace {
-            Either3::A(precompile) => Either3::A(precompile),
-            Either3::B(call) => Either3::B(call),
-            Either3::C(create) => Either3::C(create),
-        };
-
-        self.get_stack_trace_inner(trace)
-    }
-
-    pub fn get_stack_trace_inner(
-        &self,
-        trace: Either3<&PrecompileMessageTrace, &CallMessageTrace, &CreateMessageTrace>,
-    ) -> napi::Result<SolidityStackTrace> {
-        let exit = match &trace {
-            Either3::A(precompile) => &precompile.exit,
-            Either3::B(call) => &call.exit,
-            Either3::C(create) => &create.exit,
-        };
-
-        if !exit.is_error() {
-            return Ok(vec![]);
-        }
-
-        match trace {
-            Either3::A(precompile) => Ok(self.get_precompile_message_stack_trace(precompile)?),
-            Either3::B(call) if call.bytecode.is_some() => {
-                Ok(self.get_call_message_stack_trace(call)?)
-            }
-            Either3::C(create) if create.bytecode.is_some() => {
-                Ok(self.get_create_message_stack_trace(create)?)
-            }
-            // No bytecode is present
-            Either3::B(call) => Ok(self.get_unrecognized_message_stack_trace(Either::A(call))?),
-            Either3::C(create) => Ok(self.get_unrecognized_message_stack_trace(Either::B(create))?),
-        }
-    }
-
-    fn get_last_subtrace<'a>(
-        &self,
-        trace: Either<&'a CallMessageTrace, &'a CreateMessageTrace>,
-    ) -> Option<Either3<&'a PrecompileMessageTrace, &'a CallMessageTrace, &'a CreateMessageTrace>>
-    {
-        let (number_of_subtraces, steps) = match trace {
-            Either::A(create) => (create.number_of_subtraces, &create.steps),
-            Either::B(call) => (call.number_of_subtraces, &call.steps),
-        };
-
-        if number_of_subtraces == 0 {
-            return None;
-        }
-
-        steps.iter().rev().find_map(|step| match step {
-            Either4::A(EvmStep { .. }) => None,
-            Either4::B(precompile) => Some(Either3::A(precompile)),
-            Either4::C(call) => Some(Either3::B(call)),
-            Either4::D(create) => Some(Either3::C(create)),
-        })
-    }
-
-    fn get_precompile_message_stack_trace(
-        &self,
-        trace: &PrecompileMessageTrace,
-    ) -> napi::Result<SolidityStackTrace> {
-        Ok(vec![PrecompileErrorStackTraceEntry {
-            type_: StackTraceEntryTypeConst,
-            precompile: trace.precompile,
-            source_reference: None,
-        }
-        .into()])
-    }
-
-    fn get_create_message_stack_trace(
-        &self,
-        trace: &CreateMessageTrace,
-    ) -> napi::Result<SolidityStackTrace> {
-        let inferred_error = ErrorInferrer::infer_before_tracing_create_message(trace)?;
-
-        if let Some(inferred_error) = inferred_error {
-            return Ok(inferred_error);
-        }
-
-        self.trace_evm_execution(Either::B(trace))
-    }
-
-    fn get_call_message_stack_trace(
-        &self,
-        trace: &CallMessageTrace,
-    ) -> napi::Result<SolidityStackTrace> {
-        let inferred_error = ErrorInferrer::infer_before_tracing_call_message(trace)?;
-
-        if let Some(inferred_error) = inferred_error {
-            return Ok(inferred_error);
-        }
-
-        self.trace_evm_execution(Either::A(trace))
-    }
-
-    fn get_unrecognized_message_stack_trace(
-        &self,
-        trace: Either<&CallMessageTrace, &CreateMessageTrace>,
-    ) -> napi::Result<SolidityStackTrace> {
-        let (trace_exit_kind, trace_return_data) = match &trace {
-            Either::A(call) => (call.exit.kind(), &call.return_data),
-            Either::B(create) => (create.exit.kind(), &create.return_data),
-        };
-
-        let subtrace = self.get_last_subtrace(trace);
-
-        if let Some(subtrace) = subtrace {
-            let (is_error, return_data) = match subtrace {
-                Either3::A(precompile) => {
-                    (precompile.exit.is_error(), precompile.return_data.clone())
-                }
-                Either3::B(call) => (call.exit.is_error(), call.return_data.clone()),
-                Either3::C(create) => (create.exit.is_error(), create.return_data.clone()),
-            };
-
-            // This is not a very exact heuristic, but most of the time it will be right, as
-            // solidity reverts if a call fails, and most contracts are in
-            // solidity
-            if is_error && trace_return_data.as_ref() == return_data.as_ref() {
-                let unrecognized_entry: SolidityStackTraceEntry = match trace {
-                    Either::A(CallMessageTrace { address, .. }) => {
-                        UnrecognizedContractCallstackEntryStackTraceEntry {
-                            type_: StackTraceEntryTypeConst,
-                            address: address.clone(),
-                            source_reference: None,
-                        }
-                        .into()
-                    }
-                    Either::B(CreateMessageTrace { .. }) => {
-                        UnrecognizedCreateCallstackEntryStackTraceEntry {
-                            type_: StackTraceEntryTypeConst,
-                            source_reference: None,
-                        }
-                        .into()
-                    }
-                };
-
-                let mut stacktrace = vec![unrecognized_entry];
-                stacktrace.extend(self.get_stack_trace_inner(subtrace)?);
-
-                return Ok(stacktrace);
-            }
-        }
-
-        if trace_exit_kind == ExitCode::CODESIZE_EXCEEDS_MAXIMUM {
-            return Ok(vec![ContractTooLargeErrorStackTraceEntry {
-                type_: StackTraceEntryTypeConst,
-                source_reference: None,
-            }
-            .into()]);
-        }
-
-        let is_invalid_opcode_error = trace_exit_kind == ExitCode::INVALID_OPCODE;
-
-        match trace {
-            Either::A(trace @ CallMessageTrace { .. }) => {
-                Ok(vec![UnrecognizedContractErrorStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    address: trace.address.clone(),
-                    return_data: trace.return_data.clone(),
-                    is_invalid_opcode_error,
-                    source_reference: None,
-                }
-                .into()])
-            }
-            Either::B(trace @ CreateMessageTrace { .. }) => {
-                Ok(vec![UnrecognizedCreateErrorStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    return_data: trace.return_data.clone(),
-                    is_invalid_opcode_error,
-                    source_reference: None,
-                }
-                .into()])
-            }
-        }
-    }
-
-    fn trace_evm_execution(
-        &self,
-        trace: Either<&CallMessageTrace, &CreateMessageTrace>,
-    ) -> napi::Result<SolidityStackTrace> {
-        let stack_trace = self.raw_trace_evm_execution(trace)?;
-
-        if stack_trace_may_require_adjustments(&stack_trace, trace) {
-            return adjust_stack_trace(stack_trace, trace);
-        }
-
-        Ok(stack_trace)
-    }
-
-    fn raw_trace_evm_execution(
-        &self,
-        trace: Either<&CallMessageTrace, &CreateMessageTrace>,
-    ) -> napi::Result<SolidityStackTrace> {
-        let (bytecode, steps, number_of_subtraces) = match &trace {
-            Either::A(call) => (&call.bytecode, &call.steps, call.number_of_subtraces),
-            Either::B(create) => (&create.bytecode, &create.steps, create.number_of_subtraces),
-        };
-        let bytecode = bytecode.as_ref().expect("JS code asserts");
-
-        let mut stacktrace: SolidityStackTrace = vec![];
-
-        let mut subtraces_seen = 0;
-
-        // There was a jump into a function according to the sourcemaps
-        let mut jumped_into_function = false;
-
-        let mut function_jumpdests: Vec<&Instruction> = vec![];
-
-        let mut last_submessage_data: Option<SubmessageDataRef<'_>> = None;
-
-        let mut iter = steps.iter().enumerate().peekable();
-        while let Some((step_index, step)) = iter.next() {
-            if let Either4::A(EvmStep { pc }) = step {
-                let inst = bytecode.get_instruction(*pc)?;
-
-                if inst.jump_type == JumpType::IntoFunction && iter.peek().is_some() {
-                    let (_, next_step) = iter.peek().unwrap();
-                    let Either4::A(next_evm_step) = next_step else {
-                        unreachable!("JS code asserted that");
-                    };
-                    let next_inst = bytecode.get_instruction(next_evm_step.pc)?;
-
-                    if next_inst.opcode == OpCode::JUMPDEST {
-                        let frame = instruction_to_callstack_stack_trace_entry(bytecode, inst)?;
-                        stacktrace.push(match frame {
-                            Either::A(frame) => frame.into(),
-                            Either::B(frame) => frame.into(),
-                        });
-                        if next_inst.location.is_some() {
-                            jumped_into_function = true;
-                        }
-                        function_jumpdests.push(next_inst);
-                    }
-                } else if inst.jump_type == JumpType::OutofFunction {
-                    stacktrace.pop();
-                    function_jumpdests.pop();
-                }
-            } else {
-                let message_trace = match step {
-                    Either4::A(_) => unreachable!("branch is taken above"),
-                    Either4::B(precompile) => Either3::A(precompile),
-                    Either4::C(call) => Either3::B(call),
-                    Either4::D(create) => Either3::C(create),
-                };
-
-                subtraces_seen += 1;
-
-                // If there are more subtraces, this one didn't terminate the execution
-                if subtraces_seen < number_of_subtraces {
-                    continue;
-                }
-
-                let submessage_trace = self.get_stack_trace_inner(message_trace)?;
-
-                last_submessage_data = Some(SubmessageDataRef {
-                    message_trace,
-                    step_index: step_index as u32,
-                    stacktrace: submessage_trace,
-                });
-            }
-        }
-
-        let stacktrace_with_inferred_error = ErrorInferrer::infer_after_tracing(
-            trace,
-            stacktrace,
-            &function_jumpdests,
-            jumped_into_function,
-            last_submessage_data,
-        )?;
-
-        ErrorInferrer::filter_redundant_frames(stacktrace_with_inferred_error)
-    }
-}