@nomicfoundation/edr 0.5.1 → 0.6.0

package/src/trace/exit.rs

@@ -0,0 +1,86 @@
+//! Naive rewrite of `hardhat-network/provider/vm/exit.ts` from Hardhat.
+//! Used together with `VmTracer`.
+
+use std::fmt;
+
+use edr_evm::HaltReason;
+use napi_derive::napi;
+
+#[napi]
+pub struct Exit(pub(crate) ExitCode);
+
+#[napi]
+/// Represents the exit code of the EVM.
+#[derive(Debug, PartialEq, Eq)]
+#[allow(clippy::upper_case_acronyms, non_camel_case_types)] // These are exported and mapped 1:1 to existing JS enum
+pub enum ExitCode {
+    /// Execution was successful.
+    SUCCESS = 0,
+    /// Execution was reverted.
+    REVERT,
+    /// Execution ran out of gas.
+    OUT_OF_GAS,
+    /// Execution encountered an internal error.
+    INTERNAL_ERROR,
+    /// Execution encountered an invalid opcode.
+    INVALID_OPCODE,
+    /// Execution encountered a stack underflow.
+    STACK_UNDERFLOW,
+    /// Create init code size exceeds limit (runtime).
+    CODESIZE_EXCEEDS_MAXIMUM,
+    /// Create collision.
+    CREATE_COLLISION,
+}
+
+impl fmt::Display for ExitCode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ExitCode::SUCCESS => write!(f, "Success"),
+            ExitCode::REVERT => write!(f, "Reverted"),
+            ExitCode::OUT_OF_GAS => write!(f, "Out of gas"),
+            ExitCode::INTERNAL_ERROR => write!(f, "Internal error"),
+            ExitCode::INVALID_OPCODE => write!(f, "Invalid opcode"),
+            ExitCode::STACK_UNDERFLOW => write!(f, "Stack underflow"),
+            ExitCode::CODESIZE_EXCEEDS_MAXIMUM => write!(f, "Codesize exceeds maximum"),
+            ExitCode::CREATE_COLLISION => write!(f, "Create collision"),
+        }
+    }
+}
+
+#[allow(clippy::fallible_impl_from)] // naively ported for now
+impl From<edr_solidity::message_trace::ExitCode> for ExitCode {
+    fn from(code: edr_solidity::message_trace::ExitCode) -> Self {
+        use edr_solidity::message_trace::ExitCode;
+
+        match code {
+            ExitCode::Success => Self::SUCCESS,
+            ExitCode::Revert => Self::REVERT,
+            ExitCode::Halt(HaltReason::OutOfGas(_)) => Self::OUT_OF_GAS,
+            ExitCode::Halt(HaltReason::OpcodeNotFound | HaltReason::InvalidFEOpcode
+              // Returned when an opcode is not implemented for the hardfork
+              | HaltReason::NotActivated) => Self::INVALID_OPCODE,
+            ExitCode::Halt(HaltReason::StackUnderflow) => Self::STACK_UNDERFLOW,
+            ExitCode::Halt(HaltReason::CreateContractSizeLimit) => Self::CODESIZE_EXCEEDS_MAXIMUM,
+            ExitCode::Halt(HaltReason::CreateCollision) => Self::CREATE_COLLISION,
+            halt @ ExitCode::Halt(_) => panic!("Unmatched EDR exceptional halt: {halt:?}"),
+        }
+    }
+}
+
+#[napi]
+impl Exit {
+    #[napi(getter)]
+    pub fn kind(&self) -> ExitCode {
+        self.0
+    }
+
+    #[napi]
+    pub fn is_error(&self) -> bool {
+        !matches!(self.0, ExitCode::SUCCESS)
+    }
+
+    #[napi]
+    pub fn get_reason(&self) -> String {
+        self.0.to_string()
+    }
+}

package/src/trace/library_utils.rs

@@ -0,0 +1,6 @@
+use napi_derive::napi;
+
+#[napi]
+pub fn link_hex_string_bytecode(code: String, address: String, position: u32) -> String {
+    edr_solidity::library_utils::link_hex_string_bytecode(code, &address, position)
+}

package/src/trace/mapped_inlined_internal_functions_heuristics.rs

@@ -0,0 +1,180 @@
+//!  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

@@ -0,0 +1,179 @@
+//! 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/model.rs

@@ -0,0 +1,59 @@
+use std::rc::Rc;
+
+use edr_solidity::build_model::Bytecode;
+use napi_derive::napi;
+use serde::Serialize;
+
+/// Opaque handle to the `Bytecode` struct.
+/// Only used on the JS side by the `VmTraceDecoder` class.
+// NOTE: Needed, because we store the resolved `Bytecode` in the MessageTrace
+// JS plain objects and those need a dedicated (class) type.
+#[napi]
+pub struct BytecodeWrapper(pub(crate) Rc<Bytecode>);
+
+impl BytecodeWrapper {
+    pub fn new(bytecode: Rc<Bytecode>) -> Self {
+        Self(bytecode)
+    }
+
+    pub fn inner(&self) -> &Rc<Bytecode> {
+        &self.0
+    }
+}
+
+impl std::ops::Deref for BytecodeWrapper {
+    type Target = Bytecode;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Serialize)]
+#[allow(non_camel_case_types)] // intentionally mimicks the original case in TS
+#[allow(clippy::upper_case_acronyms)]
+#[napi]
+// Mimicks [`edr_solidity::build_model::ContractFunctionType`].
+pub enum ContractFunctionType {
+    CONSTRUCTOR,
+    FUNCTION,
+    FALLBACK,
+    RECEIVE,
+    GETTER,
+    MODIFIER,
+    FREE_FUNCTION,
+}
+
+impl From<edr_solidity::build_model::ContractFunctionType> for ContractFunctionType {
+    fn from(value: edr_solidity::build_model::ContractFunctionType) -> Self {
+        match value {
+            edr_solidity::build_model::ContractFunctionType::Constructor => Self::CONSTRUCTOR,
+            edr_solidity::build_model::ContractFunctionType::Function => Self::FUNCTION,
+            edr_solidity::build_model::ContractFunctionType::Fallback => Self::FALLBACK,
+            edr_solidity::build_model::ContractFunctionType::Receive => Self::RECEIVE,
+            edr_solidity::build_model::ContractFunctionType::Getter => Self::GETTER,
+            edr_solidity::build_model::ContractFunctionType::Modifier => Self::MODIFIER,
+            edr_solidity::build_model::ContractFunctionType::FreeFunction => Self::FREE_FUNCTION,
+        }
+    }
+}

package/src/trace/return_data.rs

@@ -0,0 +1,84 @@
+//! Rewrite of `hardhat-network/provider/return-data.ts` from Hardhat.
+
+use alloy_sol_types::SolError;
+use napi::bindgen_prelude::{BigInt, Uint8Array};
+use napi_derive::napi;
+
+// Built-in error types
+// See <https://docs.soliditylang.org/en/v0.8.26/control-structures.html#error-handling-assert-require-revert-and-exceptions>
+alloy_sol_types::sol! {
+  error Error(string);
+  error Panic(uint256);
+}
+
+#[napi]
+pub struct ReturnData {
+    #[napi(readonly)]
+    pub value: Uint8Array,
+    selector: Option<[u8; 4]>,
+}
+
+#[napi]
+impl ReturnData {
+    #[napi(constructor)]
+    pub fn new(value: Uint8Array) -> Self {
+        let selector = if value.len() >= 4 {
+            Some(value[0..4].try_into().unwrap())
+        } else {
+            None
+        };
+
+        Self { value, selector }
+    }
+
+    #[napi]
+    pub fn is_empty(&self) -> bool {
+        self.value.is_empty()
+    }
+
+    pub fn matches_selector(&self, selector: impl AsRef<[u8]>) -> bool {
+        self.selector
+            .map_or(false, |value| value == selector.as_ref())
+    }
+
+    #[napi]
+    pub fn is_error_return_data(&self) -> bool {
+        self.selector == Some(Error::SELECTOR)
+    }
+
+    #[napi]
+    pub fn is_panic_return_data(&self) -> bool {
+        self.selector == Some(Panic::SELECTOR)
+    }
+
+    #[napi]
+    pub fn decode_error(&self) -> napi::Result<String> {
+        if self.is_empty() {
+            return Ok(String::new());
+        }
+
+        let result = Error::abi_decode(&self.value[..], false).map_err(|_err| {
+            napi::Error::new(
+                napi::Status::InvalidArg,
+                "Expected return data to be a Error(string) and contain a valid string",
+            )
+        })?;
+
+        Ok(result._0)
+    }
+
+    #[napi]
+    pub fn decode_panic(&self) -> napi::Result<BigInt> {
+        let result = Panic::abi_decode(&self.value[..], false).map_err(|_err| {
+            napi::Error::new(
+                napi::Status::InvalidArg,
+                "Expected return data to be a Error(string) and contain a valid string",
+            )
+        })?;
+
+        Ok(BigInt {
+            sign_bit: false,
+            words: result._0.as_limbs().to_vec(),
+        })
+    }
+}