@nomicfoundation/edr 0.6.4 → 0.7.0

package/src/trace/debug.rs

@@ -1,271 +1,11 @@
 //! Port of `hardhat-network/stack-traces/debug.ts` from Hardhat.
 
-use edr_eth::U256;
-use edr_evm::{hex, interpreter::OpCode};
-use edr_solidity::build_model::JumpType;
-use napi::{
-    bindgen_prelude::{Either24, Either3, Either4},
-    Either, Env,
-};
+use napi::bindgen_prelude::Either24;
 use napi_derive::napi;
 
-use super::{
-    message_trace::{CallMessageTrace, CreateMessageTrace, PrecompileMessageTrace},
-    solidity_stack_trace::{RevertErrorStackTraceEntry, SolidityStackTrace},
-};
+use super::solidity_stack_trace::{RevertErrorStackTraceEntry, SolidityStackTrace};
 use crate::trace::return_data::ReturnData;
 
-const MARGIN_SPACE: usize = 6;
-
-#[napi]
-fn print_message_trace(
-    trace: Either3<PrecompileMessageTrace, CallMessageTrace, CreateMessageTrace>,
-    depth: Option<u32>,
-    env: Env,
-) -> napi::Result<()> {
-    let trace = match &trace {
-        Either3::A(precompile) => Either3::A(precompile),
-        Either3::B(call) => Either3::B(call),
-        Either3::C(create) => Either3::C(create),
-    };
-
-    let depth = depth.unwrap_or(0);
-
-    print_message_trace_inner(trace, depth, env)
-}
-
-fn print_message_trace_inner(
-    trace: Either3<&PrecompileMessageTrace, &CallMessageTrace, &CreateMessageTrace>,
-    depth: u32,
-    env: Env,
-) -> napi::Result<()> {
-    println!();
-
-    match trace {
-        Either3::A(precompile) => print_precompile_trace(precompile, depth),
-        Either3::B(call) => print_call_trace(call, depth, env)?,
-        Either3::C(create) => print_create_trace(create, depth, env)?,
-    }
-
-    println!();
-
-    Ok(())
-}
-
-fn print_precompile_trace(trace: &PrecompileMessageTrace, depth: u32) {
-    let margin = " ".repeat(depth as usize * MARGIN_SPACE);
-
-    let value = U256::from_limbs_slice(&trace.value.words);
-
-    println!("{margin}Precompile trace");
-
-    println!("{margin} precompile number: {}", trace.precompile);
-    println!("{margin} value: {value}");
-    println!(
-        "{margin} calldata: {}",
-        hex::encode_prefixed(&*trace.calldata)
-    );
-
-    if trace.exit.is_error() {
-        println!("{margin} error: {}", trace.exit.get_reason());
-    }
-
-    println!(
-        "{margin} returnData: {}",
-        hex::encode_prefixed(&*trace.return_data)
-    );
-}
-
-fn print_call_trace(trace: &CallMessageTrace, depth: u32, env: Env) -> napi::Result<()> {
-    let margin = " ".repeat(depth as usize * MARGIN_SPACE);
-
-    println!("{margin}Call trace");
-
-    if let Some(bytecode) = &trace.bytecode {
-        let contract = bytecode.contract.borrow();
-        let file = contract.location.file();
-        let file = file.borrow();
-
-        println!(
-            "{margin} calling contract: {}:{}",
-            file.source_name, contract.name
-        );
-    } else {
-        println!(
-            "{margin} unrecognized contract code: {:?}",
-            hex::encode_prefixed(&*trace.code)
-        );
-        println!(
-            "{margin} contract: {}",
-            hex::encode_prefixed(&*trace.address)
-        );
-    }
-
-    println!(
-        "{margin} value: {}",
-        U256::from_limbs_slice(&trace.value.words)
-    );
-    println!(
-        "{margin} calldata: {}",
-        hex::encode_prefixed(&*trace.calldata)
-    );
-
-    if trace.exit.is_error() {
-        println!("{margin} error: {}", trace.exit.get_reason());
-    }
-
-    println!(
-        "{margin} returnData: {}",
-        hex::encode_prefixed(&*trace.return_data)
-    );
-
-    trace_steps(Either::A(trace), depth, env)
-}
-
-fn print_create_trace(trace: &CreateMessageTrace, depth: u32, env: Env) -> napi::Result<()> {
-    let margin = " ".repeat(depth as usize * MARGIN_SPACE);
-
-    println!("{margin}Create trace");
-
-    if let Some(bytecode) = &trace.bytecode {
-        let contract = bytecode.contract.borrow();
-
-        println!("{margin} deploying contract: {}", contract.name);
-        println!("{margin} code: {}", hex::encode_prefixed(&*trace.code));
-    } else {
-        println!(
-            "{margin} unrecognized deployment code: {}",
-            hex::encode_prefixed(&*trace.code)
-        );
-    }
-
-    println!(
-        "{margin} value: {}",
-        U256::from_limbs_slice(&trace.value.words)
-    );
-
-    if let Some(Either::A(deployed_contract)) = &trace.deployed_contract {
-        println!(
-            "{margin} contract address: {}",
-            hex::encode_prefixed(deployed_contract)
-        );
-    }
-
-    if trace.exit.is_error() {
-        println!("{margin} error: {}", trace.exit.get_reason());
-        // The return data is the deployed-bytecode if there was no error, so we don't
-        // show it
-        println!(
-            "{margin} returnData: {}",
-            hex::encode_prefixed(&*trace.return_data)
-        );
-    }
-
-    trace_steps(Either::B(trace), depth, env)?;
-
-    Ok(())
-}
-
-fn trace_steps(
-    trace: Either<&CallMessageTrace, &CreateMessageTrace>,
-    depth: u32,
-    env: Env,
-) -> napi::Result<()> {
-    let margin = " ".repeat(depth as usize * MARGIN_SPACE);
-
-    println!("{margin} steps:");
-    println!();
-
-    let (bytecode, steps) = match &trace {
-        Either::A(call) => (&call.bytecode, &call.steps),
-        Either::B(create) => (&create.bytecode, &create.steps),
-    };
-
-    for step in steps {
-        let step = match step {
-            Either4::A(step) => step,
-            trace @ (Either4::B(..) | Either4::C(..) | Either4::D(..)) => {
-                let trace = match trace {
-                    Either4::A(..) => unreachable!(),
-                    Either4::B(precompile) => Either3::A(precompile),
-                    Either4::C(call) => Either3::B(call),
-                    Either4::D(create) => Either3::C(create),
-                };
-
-                print_message_trace_inner(trace, depth + 1, env)?;
-                continue;
-            }
-        };
-
-        let pc = format!("{:>5}", format!("{:03}", step.pc));
-
-        if let Some(bytecode) = bytecode {
-            let inst = bytecode.get_instruction(step.pc)?;
-
-            let location = inst
-                .location
-                .as_ref()
-                .map(|inst_location| {
-                    let inst_location = &inst_location;
-                    let file = inst_location.file();
-                    let file = file.borrow();
-
-                    let mut location_str = file.source_name.clone();
-
-                    if let Some(func) = inst_location.get_containing_function() {
-                        let file = func.location.file();
-                        let file = file.borrow();
-
-                        let source_name = func
-                            .contract_name
-                            .as_ref()
-                            .unwrap_or_else(|| &file.source_name);
-
-                        location_str += &format!(":{source_name}:{}", func.name);
-                    }
-                    location_str +=
-                        &format!("   -  {}:{}", inst_location.offset, inst_location.length);
-
-                    napi::Result::Ok(location_str)
-                })
-                .transpose()?
-                .unwrap_or_default();
-
-            if matches!(inst.opcode, OpCode::JUMP | OpCode::JUMPI) {
-                let jump = if inst.jump_type == JumpType::NotJump {
-                    "".to_string()
-                } else {
-                    format!("({})", inst.jump_type)
-                };
-
-                let entry = format!("{margin}  {pc}   {opcode} {jump}", opcode = inst.opcode);
-
-                println!("{entry:<50}{location}");
-            } else if inst.opcode.is_push() {
-                let entry = format!(
-                    "{margin}  {pc}   {opcode} {push_data}",
-                    opcode = inst.opcode,
-                    push_data = inst
-                        .push_data
-                        .as_deref()
-                        .map(hex::encode_prefixed)
-                        .unwrap_or_default()
-                );
-
-                println!("{entry:<50}{location}");
-            } else {
-                let entry = format!("{margin}  {pc}   {opcode}", opcode = inst.opcode);
-
-                println!("{entry:<50}{location}");
-            }
-        } else {
-            println!("{margin}  {pc}");
-        }
-    }
-
-    Ok(())
-}
-
 #[napi]
 fn print_stack_trace(trace: SolidityStackTrace) -> napi::Result<()> {
     let entry_values = trace

package/src/trace/exit.rs

@@ -30,6 +30,8 @@ pub enum ExitCode {
     CODESIZE_EXCEEDS_MAXIMUM,
     /// Create collision.
     CREATE_COLLISION,
+    /// Unknown halt reason.
+    UNKNOWN_HALT_REASON,
 }
 
 impl fmt::Display for ExitCode {
@@ -43,14 +45,15 @@ impl fmt::Display for ExitCode {
             ExitCode::STACK_UNDERFLOW => write!(f, "Stack underflow"),
             ExitCode::CODESIZE_EXCEEDS_MAXIMUM => write!(f, "Codesize exceeds maximum"),
             ExitCode::CREATE_COLLISION => write!(f, "Create collision"),
+            ExitCode::UNKNOWN_HALT_REASON => write!(f, "Unknown halt reason"),
         }
     }
 }
 
 #[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;
+impl From<edr_solidity::exit_code::ExitCode> for ExitCode {
+    fn from(code: edr_solidity::exit_code::ExitCode) -> Self {
+        use edr_solidity::exit_code::ExitCode;
 
         match code {
             ExitCode::Success => Self::SUCCESS,
@@ -62,7 +65,7 @@ impl From<edr_solidity::message_trace::ExitCode> for ExitCode {
             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:?}"),
+            ExitCode::Halt(_) => Self::UNKNOWN_HALT_REASON,
         }
     }
 }

package/src/trace/model.rs

@@ -1,6 +1,6 @@
 use std::rc::Rc;
 
-use edr_solidity::build_model::Bytecode;
+use edr_solidity::build_model::ContractMetadata;
 use napi_derive::napi;
 use serde::Serialize;
 
@@ -9,20 +9,20 @@ use serde::Serialize;
 // 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>);
+pub struct BytecodeWrapper(pub(crate) Rc<ContractMetadata>);
 
 impl BytecodeWrapper {
-    pub fn new(bytecode: Rc<Bytecode>) -> Self {
+    pub fn new(bytecode: Rc<ContractMetadata>) -> Self {
         Self(bytecode)
     }
 
-    pub fn inner(&self) -> &Rc<Bytecode> {
+    pub fn inner(&self) -> &Rc<ContractMetadata> {
         &self.0
     }
 }
 
 impl std::ops::Deref for BytecodeWrapper {
-    type Target = Bytecode;
+    type Target = ContractMetadata;
 
     fn deref(&self) -> &Self::Target {
         &self.0

package/src/trace/solidity_stack_trace.rs

@@ -8,6 +8,7 @@ use napi_derive::napi;
 use serde::{Serialize, Serializer};
 
 use super::model::ContractFunctionType;
+use crate::{cast::TryCast, trace::u256_to_bigint};
 
 #[napi]
 #[repr(u8)]
@@ -77,6 +78,20 @@ pub struct SourceReference {
     pub range: Vec<u32>,
 }
 
+impl From<edr_solidity::solidity_stack_trace::SourceReference> for SourceReference {
+    fn from(value: edr_solidity::solidity_stack_trace::SourceReference) -> Self {
+        let (range_start, range_end) = value.range;
+        Self {
+            source_name: value.source_name,
+            source_content: value.source_content,
+            contract: value.contract,
+            function: value.function,
+            line: value.line,
+            range: vec![range_start, range_end],
+        }
+    }
+}
+
 /// A [`StackTraceEntryType`] constant that is convertible to/from a
 /// `napi_value`.
 ///
@@ -113,16 +128,6 @@ impl<const ENTRY_TYPE: u8> ToNapiValue for StackTraceEntryTypeConst<ENTRY_TYPE>
     }
 }
 
-impl<const ENTRY_TYPE: u8> StackTraceEntryTypeConst<ENTRY_TYPE> {
-    #[allow(clippy::unused_self)] // less verbose than <value as ...>::as_value()
-    const fn as_value(&self) -> StackTraceEntryType {
-        match StackTraceEntryType::from_repr(ENTRY_TYPE) {
-            Some(val) => val,
-            None => panic!("Invalid StackTraceEntryType value"),
-        }
-    }
-}
-
 impl<const ENTRY_TYPE: u8> Serialize for StackTraceEntryTypeConst<ENTRY_TYPE> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -599,76 +604,215 @@ pub type SolidityStackTraceEntry = Either24<
     ContractCallRunOutOfGasError,
 >;
 
+impl TryCast<SolidityStackTraceEntry> for edr_solidity::solidity_stack_trace::StackTraceEntry {
+    type Error = napi::Error;
+
+    fn try_cast(self) -> Result<SolidityStackTraceEntry, Self::Error> {
+        use edr_solidity::solidity_stack_trace::StackTraceEntry;
+        let result = match self {
+            StackTraceEntry::CallstackEntry {
+                source_reference,
+                function_type,
+            } => CallstackEntryStackTraceEntry {
+                type_: StackTraceEntryTypeConst,
+                source_reference: source_reference.into(),
+                function_type: function_type.into(),
+            }
+            .into(),
+            StackTraceEntry::UnrecognizedCreateCallstackEntry => {
+                UnrecognizedCreateCallstackEntryStackTraceEntry {
+                    type_: StackTraceEntryTypeConst,
+                    source_reference: None,
+                }
+                .into()
+            }
+            StackTraceEntry::UnrecognizedContractCallstackEntry { address } => {
+                UnrecognizedContractCallstackEntryStackTraceEntry {
+                    type_: StackTraceEntryTypeConst,
+                    address: Uint8Array::from(address.as_slice()),
+                    source_reference: None,
+                }
+                .into()
+            }
+            StackTraceEntry::PrecompileError { precompile } => PrecompileErrorStackTraceEntry {
+                type_: StackTraceEntryTypeConst,
+                precompile,
+                source_reference: None,
+            }
+            .into(),
+            StackTraceEntry::RevertError {
+                return_data,
+                source_reference,
+                is_invalid_opcode_error,
+            } => RevertErrorStackTraceEntry {
+                type_: StackTraceEntryTypeConst,
+                return_data: return_data.into(),
+                source_reference: source_reference.into(),
+                is_invalid_opcode_error,
+            }
+            .into(),
+            StackTraceEntry::PanicError {
+                error_code,
+                source_reference,
+            } => PanicErrorStackTraceEntry {
+                type_: StackTraceEntryTypeConst,
+                error_code: u256_to_bigint(&error_code),
+                source_reference: source_reference.map(std::convert::Into::into),
+            }
+            .into(),
+            StackTraceEntry::CustomError {
+                message,
+                source_reference,
+            } => CustomErrorStackTraceEntry {
+                type_: StackTraceEntryTypeConst,
+                message,
+                source_reference: source_reference.into(),
+            }
+            .into(),
+            StackTraceEntry::FunctionNotPayableError {
+                value,
+                source_reference,
+            } => FunctionNotPayableErrorStackTraceEntry {
+                type_: StackTraceEntryTypeConst,
+                value: u256_to_bigint(&value),
+                source_reference: source_reference.into(),
+            }
+            .into(),
+            StackTraceEntry::InvalidParamsError { source_reference } => {
+                InvalidParamsErrorStackTraceEntry {
+                    type_: StackTraceEntryTypeConst,
+                    source_reference: source_reference.into(),
+                }
+                .into()
+            }
+            StackTraceEntry::FallbackNotPayableError {
+                value,
+                source_reference,
+            } => FallbackNotPayableErrorStackTraceEntry {
+                type_: StackTraceEntryTypeConst,
+                value: u256_to_bigint(&value),
+                source_reference: source_reference.into(),
+            }
+            .into(),
+            StackTraceEntry::FallbackNotPayableAndNoReceiveError {
+                value,
+                source_reference,
+            } => FallbackNotPayableAndNoReceiveErrorStackTraceEntry {
+                type_: StackTraceEntryTypeConst,
+                value: u256_to_bigint(&value),
+                source_reference: source_reference.into(),
+            }
+            .into(),
+            StackTraceEntry::UnrecognizedFunctionWithoutFallbackError { source_reference } => {
+                UnrecognizedFunctionWithoutFallbackErrorStackTraceEntry {
+                    type_: StackTraceEntryTypeConst,
+                    source_reference: source_reference.into(),
+                }
+                .into()
+            }
+            StackTraceEntry::MissingFallbackOrReceiveError { source_reference } => {
+                MissingFallbackOrReceiveErrorStackTraceEntry {
+                    type_: StackTraceEntryTypeConst,
+                    source_reference: source_reference.into(),
+                }
+                .into()
+            }
+            StackTraceEntry::ReturndataSizeError { source_reference } => {
+                ReturndataSizeErrorStackTraceEntry {
+                    type_: StackTraceEntryTypeConst,
+                    source_reference: source_reference.into(),
+                }
+                .into()
+            }
+            StackTraceEntry::NoncontractAccountCalledError { source_reference } => {
+                NonContractAccountCalledErrorStackTraceEntry {
+                    type_: StackTraceEntryTypeConst,
+                    source_reference: source_reference.into(),
+                }
+                .into()
+            }
+            StackTraceEntry::CallFailedError { source_reference } => {
+                CallFailedErrorStackTraceEntry {
+                    type_: StackTraceEntryTypeConst,
+                    source_reference: source_reference.into(),
+                }
+                .into()
+            }
+            StackTraceEntry::DirectLibraryCallError { source_reference } => {
+                DirectLibraryCallErrorStackTraceEntry {
+                    type_: StackTraceEntryTypeConst,
+                    source_reference: source_reference.into(),
+                }
+                .into()
+            }
+            StackTraceEntry::UnrecognizedCreateError {
+                return_data,
+                is_invalid_opcode_error,
+            } => UnrecognizedCreateErrorStackTraceEntry {
+                type_: StackTraceEntryTypeConst,
+                return_data: return_data.into(),
+                is_invalid_opcode_error,
+                source_reference: None,
+            }
+            .into(),
+            StackTraceEntry::UnrecognizedContractError {
+                address,
+                return_data,
+                is_invalid_opcode_error,
+            } => UnrecognizedContractErrorStackTraceEntry {
+                type_: StackTraceEntryTypeConst,
+                address: Uint8Array::from(address.as_slice()),
+                return_data: return_data.into(),
+                is_invalid_opcode_error,
+                source_reference: None,
+            }
+            .into(),
+            StackTraceEntry::OtherExecutionError { source_reference } => {
+                OtherExecutionErrorStackTraceEntry {
+                    type_: StackTraceEntryTypeConst,
+                    source_reference: source_reference.map(std::convert::Into::into),
+                }
+                .into()
+            }
+            StackTraceEntry::UnmappedSolc0_6_3RevertError { source_reference } => {
+                UnmappedSolc063RevertErrorStackTraceEntry {
+                    type_: StackTraceEntryTypeConst,
+                    source_reference: source_reference.map(std::convert::Into::into),
+                }
+                .into()
+            }
+            StackTraceEntry::ContractTooLargeError { source_reference } => {
+                ContractTooLargeErrorStackTraceEntry {
+                    type_: StackTraceEntryTypeConst,
+                    source_reference: source_reference.map(std::convert::Into::into),
+                }
+                .into()
+            }
+            StackTraceEntry::InternalFunctionCallstackEntry {
+                pc,
+                source_reference,
+            } => InternalFunctionCallStackEntry {
+                type_: StackTraceEntryTypeConst,
+                pc,
+                source_reference: source_reference.into(),
+            }
+            .into(),
+            StackTraceEntry::ContractCallRunOutOfGasError { source_reference } => {
+                ContractCallRunOutOfGasError {
+                    type_: StackTraceEntryTypeConst,
+                    source_reference: source_reference.map(std::convert::Into::into),
+                }
+                .into()
+            }
+        };
+        Ok(result)
+    }
+}
+
 #[allow(dead_code)]
 // Same as above, but for the `SolidityStackTrace` type.
 pub type SolidityStackTrace = Vec<SolidityStackTraceEntry>;
 
-pub trait SolidityStackTraceEntryExt {
-    fn type_(&self) -> StackTraceEntryType;
-    fn source_reference(&self) -> Option<&SourceReference>;
-}
-
-impl SolidityStackTraceEntryExt for SolidityStackTraceEntry {
-    fn type_(&self) -> StackTraceEntryType {
-        match self {
-            Either24::A(entry) => entry.type_.as_value(),
-            Either24::B(entry) => entry.type_.as_value(),
-            Either24::C(entry) => entry.type_.as_value(),
-            Either24::D(entry) => entry.type_.as_value(),
-            Either24::E(entry) => entry.type_.as_value(),
-            Either24::F(entry) => entry.type_.as_value(),
-            Either24::G(entry) => entry.type_.as_value(),
-            Either24::H(entry) => entry.type_.as_value(),
-            Either24::I(entry) => entry.type_.as_value(),
-            Either24::J(entry) => entry.type_.as_value(),
-            Either24::K(entry) => entry.type_.as_value(),
-            Either24::L(entry) => entry.type_.as_value(),
-            Either24::M(entry) => entry.type_.as_value(),
-            Either24::N(entry) => entry.type_.as_value(),
-            Either24::O(entry) => entry.type_.as_value(),
-            Either24::P(entry) => entry.type_.as_value(),
-            Either24::Q(entry) => entry.type_.as_value(),
-            Either24::R(entry) => entry.type_.as_value(),
-            Either24::S(entry) => entry.type_.as_value(),
-            Either24::T(entry) => entry.type_.as_value(),
-            Either24::U(entry) => entry.type_.as_value(),
-            Either24::V(entry) => entry.type_.as_value(),
-            Either24::W(entry) => entry.type_.as_value(),
-            Either24::X(entry) => entry.type_.as_value(),
-        }
-    }
-
-    #[allow(clippy::unnecessary_lazy_evaluations)] // guards against potential variant reordering
-    fn source_reference(&self) -> Option<&SourceReference> {
-        match self {
-            Either24::A(entry) => Some(&entry.source_reference),
-            Either24::B(entry) => entry.source_reference.and_then(|_: ()| None),
-            Either24::C(entry) => entry.source_reference.and_then(|_: ()| None),
-            Either24::D(entry) => entry.source_reference.and_then(|_: ()| None),
-            Either24::E(entry) => Some(&entry.source_reference),
-            Either24::F(entry) => entry.source_reference.as_ref(),
-            Either24::G(entry) => Some(&entry.source_reference),
-            Either24::H(entry) => Some(&entry.source_reference),
-            Either24::I(entry) => Some(&entry.source_reference),
-            Either24::J(entry) => Some(&entry.source_reference),
-            Either24::K(entry) => Some(&entry.source_reference),
-            Either24::L(entry) => Some(&entry.source_reference),
-            Either24::M(entry) => Some(&entry.source_reference),
-            Either24::N(entry) => Some(&entry.source_reference),
-            Either24::O(entry) => Some(&entry.source_reference),
-            Either24::P(entry) => Some(&entry.source_reference),
-            Either24::Q(entry) => Some(&entry.source_reference),
-            Either24::R(entry) => entry.source_reference.and_then(|_: ()| None),
-            Either24::S(entry) => entry.source_reference.and_then(|_: ()| None),
-            Either24::T(entry) => entry.source_reference.as_ref(),
-            Either24::U(entry) => entry.source_reference.as_ref(),
-            Either24::V(entry) => entry.source_reference.as_ref(),
-            Either24::W(entry) => Some(&entry.source_reference),
-            Either24::X(entry) => entry.source_reference.as_ref(),
-        }
-    }
-}
-
 const _: () = {
     const fn assert_to_from_napi_value<T: FromNapiValue + ToNapiValue>() {}
     assert_to_from_napi_value::<SolidityStackTraceEntry>();