@nomicfoundation/edr 0.5.2 → 0.6.1

package/src/trace/solidity_tracer.rs

@@ -0,0 +1,315 @@
+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)
+    }
+}

package/src/trace/vm_trace_decoder.rs

@@ -0,0 +1,234 @@
+use std::rc::Rc;
+
+use edr_solidity::{
+    artifacts::BuildInfo,
+    build_model::{Bytecode, ContractFunctionType},
+    compiler::create_models_and_decode_bytecodes,
+    contracts_identifier::ContractsIdentifier,
+};
+use napi::{
+    bindgen_prelude::{ClassInstance, Either3, Either4, Uint8Array, Undefined},
+    Either, Env,
+};
+use napi_derive::napi;
+use serde::{Deserialize, Serialize};
+
+use super::{
+    message_trace::{CallMessageTrace, CreateMessageTrace, PrecompileMessageTrace},
+    solidity_stack_trace::{
+        FALLBACK_FUNCTION_NAME, RECEIVE_FUNCTION_NAME, UNRECOGNIZED_CONTRACT_NAME,
+        UNRECOGNIZED_FUNCTION_NAME,
+    },
+};
+use crate::trace::model::BytecodeWrapper;
+
+#[derive(Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TracingConfig {
+    pub build_infos: Option<Vec<BuildInfo>>,
+    pub ignore_contracts: Option<bool>,
+}
+
+#[derive(Default)]
+#[napi]
+pub struct VmTraceDecoder {
+    contracts_identifier: ContractsIdentifier,
+}
+
+#[napi]
+impl VmTraceDecoder {
+    #[napi(constructor)]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    #[napi(catch_unwind)]
+    pub fn add_bytecode(&mut self, bytecode: ClassInstance<BytecodeWrapper>) {
+        self.add_bytecode_inner(bytecode.inner().clone());
+    }
+
+    pub fn add_bytecode_inner(&mut self, bytecode: Rc<Bytecode>) {
+        self.contracts_identifier.add_bytecode(bytecode);
+    }
+
+    #[napi(catch_unwind)]
+    pub fn try_to_decode_message_trace(
+        &mut self,
+        message_trace: Either3<PrecompileMessageTrace, CallMessageTrace, CreateMessageTrace>,
+        env: Env,
+    ) -> napi::Result<Either3<PrecompileMessageTrace, CallMessageTrace, CreateMessageTrace>> {
+        match message_trace {
+            precompile @ Either3::A(..) => Ok(precompile),
+            // NOTE: The branches below are the same with the difference of `is_create`
+            Either3::B(mut call) => {
+                let is_create = false;
+
+                let bytecode = self
+                    .contracts_identifier
+                    .get_bytecode_for_call(call.code.as_ref(), is_create);
+
+                let steps: Vec<_> = call
+                    .steps
+                    .into_iter()
+                    .map(|step| {
+                        let trace = match step {
+                            Either4::A(step) => return Ok(Either4::A(step)),
+                            Either4::B(precompile) => Either3::A(precompile),
+                            Either4::C(create) => Either3::B(create),
+                            Either4::D(call) => Either3::C(call),
+                        };
+
+                        Ok(match self.try_to_decode_message_trace(trace, env)? {
+                            Either3::A(precompile) => Either4::B(precompile),
+                            Either3::B(create) => Either4::C(create),
+                            Either3::C(call) => Either4::D(call),
+                        })
+                    })
+                    .collect::<napi::Result<_>>()?;
+
+                let bytecode = bytecode
+                    .map(|b| BytecodeWrapper::new(b).into_instance(env))
+                    .transpose()?;
+
+                call.bytecode = bytecode;
+                call.steps = steps;
+
+                Ok(Either3::B(call))
+            }
+            Either3::C(mut create @ CreateMessageTrace { .. }) => {
+                let is_create = true;
+
+                let bytecode = self
+                    .contracts_identifier
+                    .get_bytecode_for_call(create.code.as_ref(), is_create);
+
+                let steps: Vec<_> = create
+                    .steps
+                    .into_iter()
+                    .map(|step| {
+                        let trace = match step {
+                            Either4::A(step) => return Ok(Either4::A(step)),
+                            Either4::B(precompile) => Either3::A(precompile),
+                            Either4::C(create) => Either3::B(create),
+                            Either4::D(call) => Either3::C(call),
+                        };
+
+                        Ok(match self.try_to_decode_message_trace(trace, env)? {
+                            Either3::A(precompile) => Either4::B(precompile),
+                            Either3::B(create) => Either4::C(create),
+                            Either3::C(call) => Either4::D(call),
+                        })
+                    })
+                    .collect::<napi::Result<_>>()?;
+
+                let bytecode = bytecode
+                    .map(|b| BytecodeWrapper::new(b).into_instance(env))
+                    .transpose()?;
+                create.bytecode = bytecode;
+                create.steps = steps;
+
+                Ok(Either3::C(create))
+            }
+        }
+    }
+
+    #[napi]
+    pub fn get_contract_and_function_names_for_call(
+        &mut self,
+        code: Uint8Array,
+        calldata: Either<Uint8Array, Undefined>,
+    ) -> napi::Result<ContractAndFunctionName> {
+        let is_create = matches!(calldata, Either::B(()));
+        let bytecode = self
+            .contracts_identifier
+            .get_bytecode_for_call(code.as_ref(), is_create);
+
+        let contract = bytecode.map(|bytecode| bytecode.contract.clone());
+        let contract = contract.as_ref().map(|c| c.borrow());
+
+        let contract_name = contract.as_ref().map_or_else(
+            || UNRECOGNIZED_CONTRACT_NAME.to_string(),
+            |c| c.name.clone(),
+        );
+
+        if is_create {
+            Ok(ContractAndFunctionName {
+                contract_name,
+                function_name: Either::B(()),
+            })
+        } else {
+            match contract {
+                None => Ok(ContractAndFunctionName {
+                    contract_name,
+                    function_name: Either::A("".to_string()),
+                }),
+                Some(contract) => {
+                    let calldata = match calldata {
+                        Either::A(calldata) => calldata,
+                        Either::B(_) => {
+                            unreachable!("calldata should be Some if is_create is false")
+                        }
+                    };
+
+                    let selector = &calldata.get(..4).unwrap_or(&calldata[..]);
+
+                    let func = contract.get_function_from_selector(selector);
+
+                    let function_name = match func {
+                        Some(func) => match func.r#type {
+                            ContractFunctionType::Fallback => FALLBACK_FUNCTION_NAME.to_string(),
+                            ContractFunctionType::Receive => RECEIVE_FUNCTION_NAME.to_string(),
+                            _ => func.name.clone(),
+                        },
+                        None => UNRECOGNIZED_FUNCTION_NAME.to_string(),
+                    };
+
+                    Ok(ContractAndFunctionName {
+                        contract_name,
+                        function_name: Either::A(function_name),
+                    })
+                }
+            }
+        }
+    }
+}
+
+#[napi(object)]
+pub struct ContractAndFunctionName {
+    pub contract_name: String,
+    pub function_name: Either<String, Undefined>,
+}
+
+#[napi(catch_unwind)]
+pub fn initialize_vm_trace_decoder(
+    mut vm_trace_decoder: ClassInstance<VmTraceDecoder>,
+    tracing_config: serde_json::Value,
+) -> napi::Result<()> {
+    let config = serde_json::from_value::<TracingConfig>(tracing_config).map_err(|e| {
+        napi::Error::from_reason(format!("Failed to deserialize tracing config: {e:?}"))
+    })?;
+
+    let Some(build_infos) = config.build_infos else {
+        return Ok(());
+    };
+
+    for build_info in &build_infos {
+        let bytecodes = create_models_and_decode_bytecodes(
+            build_info.solc_version.clone(),
+            &build_info.input,
+            &build_info.output,
+        )?;
+
+        for bytecode in bytecodes {
+            if config.ignore_contracts == Some(true)
+                && bytecode.contract.borrow().name.starts_with("Ignored")
+            {
+                continue;
+            }
+
+            vm_trace_decoder.add_bytecode_inner(Rc::new(bytecode));
+        }
+    }
+
+    Ok(())
+}

package/src/trace/vm_tracer.rs

@@ -0,0 +1,71 @@
+//! N-API bindings for the Rust port of `VMTracer` from Hardhat.
+
+use napi::{
+    bindgen_prelude::{Either3, Either4, Undefined},
+    Either, Env, JsError,
+};
+use napi_derive::napi;
+
+use crate::trace::{
+    message_trace::{
+        message_trace_to_napi, CallMessageTrace, CreateMessageTrace, PrecompileMessageTrace,
+    },
+    RawTrace,
+};
+
+/// N-API bindings for the Rust port of `VMTracer` from Hardhat.
+#[napi]
+pub struct VMTracer(edr_solidity::vm_tracer::VmTracer);
+
+#[napi]
+impl VMTracer {
+    #[napi(constructor)]
+    pub fn new() -> napi::Result<Self> {
+        Ok(Self(edr_solidity::vm_tracer::VmTracer::new()))
+    }
+
+    /// Observes a trace, collecting information about the execution of the EVM.
+    #[napi]
+    pub fn observe(&mut self, trace: &RawTrace) {
+        self.0.observe(&trace.inner);
+    }
+
+    // Explicitly return undefined as `Option<T>` by default returns `null` in JS
+    // and the null/undefined checks we use in JS are strict
+    #[napi]
+    pub fn get_last_top_level_message_trace(
+        &self,
+        env: Env,
+    ) -> napi::Result<
+        Either4<PrecompileMessageTrace, CallMessageTrace, CreateMessageTrace, Undefined>,
+    > {
+        Ok(
+            match self
+                .0
+                .get_last_top_level_message_trace_ref()
+                .map(|x| {
+                    x.try_borrow()
+                        .expect("cannot be executed concurrently with `VMTracer::observe`")
+                        .clone()
+                })
+                .map(|msg| message_trace_to_napi(msg, env))
+                .transpose()?
+            {
+                Some(Either3::A(precompile)) => Either4::A(precompile),
+                Some(Either3::B(call)) => Either4::B(call),
+                Some(Either3::C(create)) => Either4::C(create),
+                None => Either4::D(()),
+            },
+        )
+    }
+
+    // Explicitly return undefined as `Option<T>` by default returns `null` in JS
+    // and the null/undefined checks we use in JS are strict
+    #[napi]
+    pub fn get_last_error(&self) -> Either<JsError, Undefined> {
+        match self.0.get_last_error() {
+            Some(err) => Either::A(napi::Error::from_reason(err).into()),
+            None => Either::B(()),
+        }
+    }
+}

package/src/trace.rs

@@ -1,3 +1,10 @@
+// In contrast to the functions in the `#[napi] impl XYZ` block,
+// the free functions `#[napi] pub fn` are exported by napi-rs but
+// are considered dead code in the (lib test) target.
+// For now, we silence the relevant warnings, as we need to mimick
+// the original API while we rewrite the stack trace refinement to Rust.
+#![cfg_attr(test, allow(dead_code))]
+
 use std::sync::Arc;
 
 use edr_evm::{interpreter::OpCode, trace::BeforeMessage};
@@ -9,6 +16,21 @@ use napi_derive::napi;
 
 use crate::result::ExecutionResult;
 
+mod compiler;
+mod library_utils;
+mod model;
+
+mod debug;
+mod error_inferrer;
+mod exit;
+mod mapped_inlined_internal_functions_heuristics;
+mod message_trace;
+mod return_data;
+mod solidity_stack_trace;
+mod solidity_tracer;
+mod vm_trace_decoder;
+mod vm_tracer;
+
 #[napi(object)]
 pub struct TracingMessage {
     /// Sender address
@@ -151,7 +173,7 @@ pub struct TracingMessageResult {
 
 #[napi]
 pub struct RawTrace {
-    inner: Arc<edr_evm::trace::Trace>,
+    pub(crate) inner: Arc<edr_evm::trace::Trace>,
 }
 
 impl RawTrace {