@nomicfoundation/edr 0.11.3 → 0.12.0-next.0

package/src/solidity_tests.rs

@@ -0,0 +1,56 @@
+pub mod artifact;
+pub mod config;
+pub mod factory;
+pub mod l1;
+#[cfg(feature = "op")]
+pub mod op;
+pub mod runner;
+pub mod test_results;
+
+use std::path::Path;
+
+use edr_eth::Bytes;
+use edr_solidity::linker::{LinkOutput, Linker};
+use edr_solidity_tests::{constants::LIBRARY_DEPLOYER, contracts::ContractsByArtifact};
+use foundry_compilers::artifacts::Libraries;
+
+use crate::solidity_tests::artifact::Artifact;
+
+pub(crate) struct LinkingOutput {
+    pub libs_to_deploy: Vec<Bytes>,
+    pub known_contracts: ContractsByArtifact,
+}
+
+impl LinkingOutput {
+    pub fn link(project_root: &Path, artifacts: Vec<Artifact>) -> napi::Result<Self> {
+        let artifact_contracts = artifacts
+            .into_iter()
+            .map(|artifact| Ok((artifact.id.try_into()?, artifact.contract.try_into()?)))
+            .collect::<napi::Result<Vec<_>>>()?;
+
+        let linker = Linker::new(project_root, artifact_contracts);
+
+        let LinkOutput {
+            libraries,
+            libs_to_deploy,
+        } = linker
+            .link_with_nonce_or_address(
+                Libraries::default(),
+                LIBRARY_DEPLOYER,
+                0,
+                linker.contracts.keys(),
+            )
+            .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+        let linked_contracts = linker
+            .get_linked_artifacts(&libraries)
+            .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+        let known_contracts = ContractsByArtifact::new(linked_contracts);
+
+        Ok(LinkingOutput {
+            libs_to_deploy,
+            known_contracts,
+        })
+    }
+}

package/src/subscription.rs

@@ -0,0 +1,32 @@
+use napi::{bindgen_prelude::BigInt, JsFunction};
+use napi_derive::napi;
+
+/// Configuration for subscriptions.
+#[napi(object)]
+pub struct SubscriptionConfig {
+    /// Callback to be called when a new event is received.
+    #[napi(ts_type = "(event: SubscriptionEvent) => void")]
+    pub subscription_callback: JsFunction,
+}
+
+impl From<edr_napi_core::subscription::Config> for SubscriptionConfig {
+    fn from(config: edr_napi_core::subscription::Config) -> Self {
+        Self {
+            subscription_callback: config.subscription_callback,
+        }
+    }
+}
+
+impl From<SubscriptionConfig> for edr_napi_core::subscription::Config {
+    fn from(config: SubscriptionConfig) -> Self {
+        Self {
+            subscription_callback: config.subscription_callback,
+        }
+    }
+}
+
+#[napi(object)]
+pub struct SubscriptionEvent {
+    pub filter_id: BigInt,
+    pub result: serde_json::Value,
+}

package/src/trace/debug.rs

@@ -6,7 +6,7 @@ use napi_derive::napi;
 use super::solidity_stack_trace::{RevertErrorStackTraceEntry, SolidityStackTrace};
 use crate::trace::return_data::ReturnData;
 
-#[napi]
+#[napi(catch_unwind)]
 fn print_stack_trace(trace: SolidityStackTrace) -> napi::Result<()> {
     let entry_values = trace
         .into_iter()

package/src/trace/exit.rs

@@ -3,7 +3,6 @@
 
 use std::fmt;
 
-use edr_evm::HaltReason;
 use napi_derive::napi;
 
 #[napi]
@@ -51,38 +50,38 @@ impl fmt::Display for ExitCode {
 }
 
 #[allow(clippy::fallible_impl_from)] // naively ported for now
-impl From<edr_solidity::exit_code::ExitCode> for ExitCode {
-    fn from(code: edr_solidity::exit_code::ExitCode) -> Self {
+impl From<edr_solidity::exit_code::ExitCode<edr_eth::l1::HaltReason>> for ExitCode {
+    fn from(code: edr_solidity::exit_code::ExitCode<edr_eth::l1::HaltReason>) -> Self {
         use edr_solidity::exit_code::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
+            ExitCode::Halt(edr_eth::l1::HaltReason::OutOfGas(_)) => Self::OUT_OF_GAS,
+            ExitCode::Halt(edr_eth::l1::HaltReason::OpcodeNotFound | edr_eth::l1::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,
-            ExitCode::Halt(_) => Self::UNKNOWN_HALT_REASON,
+              | edr_eth::l1::HaltReason::NotActivated) => Self::INVALID_OPCODE,
+            ExitCode::Halt(edr_eth::l1::HaltReason::StackUnderflow) => Self::STACK_UNDERFLOW,
+            ExitCode::Halt(edr_eth::l1::HaltReason::CreateContractSizeLimit) => Self::CODESIZE_EXCEEDS_MAXIMUM,
+            ExitCode::Halt(edr_eth::l1::HaltReason::CreateCollision) => Self::CREATE_COLLISION,
+            _ => Self::UNKNOWN_HALT_REASON,
         }
     }
 }
 
 #[napi]
 impl Exit {
-    #[napi(getter)]
+    #[napi(catch_unwind, getter)]
     pub fn kind(&self) -> ExitCode {
         self.0
     }
 
-    #[napi]
+    #[napi(catch_unwind)]
     pub fn is_error(&self) -> bool {
         !matches!(self.0, ExitCode::SUCCESS)
     }
 
-    #[napi]
+    #[napi(catch_unwind)]
     pub fn get_reason(&self) -> String {
         self.0.to_string()
     }

package/src/trace/library_utils.rs

@@ -1,6 +1,6 @@
 use napi_derive::napi;
 
-#[napi]
+#[napi(catch_unwind)]
 pub fn link_hex_string_bytecode(
     code: String,
     address: String,

package/src/trace/return_data.rs

@@ -20,7 +20,7 @@ pub struct ReturnData {
 
 #[napi]
 impl ReturnData {
-    #[napi(constructor)]
+    #[napi(catch_unwind, constructor)]
     pub fn new(value: Uint8Array) -> Self {
         let selector = if value.len() >= 4 {
             Some(value[0..4].try_into().unwrap())
@@ -31,45 +31,45 @@ impl ReturnData {
         Self { value, selector }
     }
 
-    #[napi]
+    #[napi(catch_unwind)]
     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())
+            .is_some_and(|value| value == selector.as_ref())
     }
 
-    #[napi]
+    #[napi(catch_unwind)]
     pub fn is_error_return_data(&self) -> bool {
         self.selector == Some(Error::SELECTOR)
     }
 
-    #[napi]
+    #[napi(catch_unwind)]
     pub fn is_panic_return_data(&self) -> bool {
         self.selector == Some(Panic::SELECTOR)
     }
 
-    #[napi]
+    #[napi(catch_unwind)]
     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| {
+        let result = Error::abi_decode(&self.value[..]).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)
+        Ok(result.0)
     }
 
-    #[napi]
+    #[napi(catch_unwind)]
     pub fn decode_panic(&self) -> napi::Result<BigInt> {
-        let result = Panic::abi_decode(&self.value[..], false).map_err(|_err| {
+        let result = Panic::abi_decode(&self.value[..]).map_err(|_err| {
             napi::Error::new(
                 napi::Status::InvalidArg,
                 "Expected return data to be a Error(string) and contain a valid string",
@@ -78,7 +78,7 @@ impl ReturnData {
 
         Ok(BigInt {
             sign_bit: false,
-            words: result._0.as_limbs().to_vec(),
+            words: result.0.as_limbs().to_vec(),
         })
     }
 }

package/src/trace/solidity_stack_trace.rs

@@ -1,8 +1,9 @@
 //! Naive rewrite of `hardhat-network/stack-traces/solidity-stack-traces.ts`
 //! from Hardhat.
 
-use edr_eth::U256;
-use edr_evm::hex;
+use std::convert::Infallible;
+
+use edr_eth::{hex, U256};
 use napi::bindgen_prelude::{BigInt, Either24, FromNapiValue, ToNapiValue, Uint8Array, Undefined};
 use napi_derive::napi;
 use serde::{Serialize, Serializer};
@@ -46,7 +47,7 @@ pub enum StackTraceEntryType {
     CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR,
 }
 
-#[napi]
+#[napi(catch_unwind)]
 pub fn stack_trace_entry_type_to_string(val: StackTraceEntryType) -> &'static str {
     val.into()
 }
@@ -107,7 +108,8 @@ impl<const ENTRY_TYPE: u8> FromNapiValue for StackTraceEntryTypeConst<ENTRY_TYPE
         env: napi::sys::napi_env,
         napi_val: napi::sys::napi_value,
     ) -> napi::Result<Self> {
-        let inner: u8 = FromNapiValue::from_napi_value(env, napi_val)?;
+        // SAFETY: The safety concern is propagated in the function signature.
+        let inner: u8 = unsafe { FromNapiValue::from_napi_value(env, napi_val) }?;
 
         if inner != ENTRY_TYPE {
             return Err(napi::Error::new(
@@ -124,7 +126,8 @@ impl<const ENTRY_TYPE: u8> ToNapiValue for StackTraceEntryTypeConst<ENTRY_TYPE>
         env: napi::sys::napi_env,
         _val: Self,
     ) -> napi::Result<napi::sys::napi_value> {
-        u8::to_napi_value(env, ENTRY_TYPE)
+        // SAFETY: The safety concern is propagated in the function signature.
+        unsafe { u8::to_napi_value(env, ENTRY_TYPE) }
     }
 }
 
@@ -605,7 +608,7 @@ pub type SolidityStackTraceEntry = Either24<
 >;
 
 impl TryCast<SolidityStackTraceEntry> for edr_solidity::solidity_stack_trace::StackTraceEntry {
-    type Error = napi::Error;
+    type Error = Infallible;
 
     fn try_cast(self) -> Result<SolidityStackTraceEntry, Self::Error> {
         use edr_solidity::solidity_stack_trace::StackTraceEntry;
@@ -629,7 +632,7 @@ impl TryCast<SolidityStackTraceEntry> for edr_solidity::solidity_stack_trace::St
             StackTraceEntry::UnrecognizedContractCallstackEntry { address } => {
                 UnrecognizedContractCallstackEntryStackTraceEntry {
                     type_: StackTraceEntryTypeConst,
-                    address: Uint8Array::from(address.as_slice()),
+                    address: Uint8Array::with_data_copied(address),
                     source_reference: None,
                 }
                 .into()
@@ -761,7 +764,7 @@ impl TryCast<SolidityStackTraceEntry> for edr_solidity::solidity_stack_trace::St
                 is_invalid_opcode_error,
             } => UnrecognizedContractErrorStackTraceEntry {
                 type_: StackTraceEntryTypeConst,
-                address: Uint8Array::from(address.as_slice()),
+                address: Uint8Array::with_data_copied(address),
                 return_data: return_data.into(),
                 is_invalid_opcode_error,
                 source_reference: None,

package/src/trace.rs

@@ -7,11 +7,9 @@
 
 use std::sync::Arc;
 
-use edr_evm::{interpreter::OpCode, trace::BeforeMessage};
-use napi::{
-    bindgen_prelude::{BigInt, Buffer, Either3},
-    Env, JsBuffer, JsBufferValue,
-};
+use edr_eth::{bytecode::opcode::OpCode, l1};
+use edr_evm::trace::BeforeMessage;
+use napi::bindgen_prelude::{BigInt, Either3, Uint8Array};
 use napi_derive::napi;
 
 use crate::result::ExecutionResult;
@@ -28,11 +26,11 @@ pub mod solidity_stack_trace;
 pub struct TracingMessage {
     /// Sender address
     #[napi(readonly)]
-    pub caller: Buffer,
+    pub caller: Uint8Array,
 
     /// Recipient address. None if it is a Create message.
     #[napi(readonly)]
-    pub to: Option<Buffer>,
+    pub to: Option<Uint8Array>,
 
     /// Whether it's a static call
     #[napi(readonly)]
@@ -48,7 +46,7 @@ pub struct TracingMessage {
 
     /// Input data of the message
     #[napi(readonly)]
-    pub data: JsBuffer,
+    pub data: Uint8Array,
 
     /// Value sent in the message
     #[napi(readonly)]
@@ -57,41 +55,37 @@ pub struct TracingMessage {
     /// Address of the code that is being executed. Can be different from `to`
     /// if a delegate call is being done.
     #[napi(readonly)]
-    pub code_address: Option<Buffer>,
+    pub code_address: Option<Uint8Array>,
 
     /// Code of the contract that is being executed.
     #[napi(readonly)]
-    pub code: Option<JsBuffer>,
+    pub code: Option<Uint8Array>,
 }
 
-impl TracingMessage {
-    pub fn new(env: &Env, message: &BeforeMessage) -> napi::Result<Self> {
+impl From<&BeforeMessage> for TracingMessage {
+    fn from(value: &BeforeMessage) -> Self {
         // Deconstruct to make sure all fields are handled
         let BeforeMessage {
             depth,
             caller,
-            to: _,
+            to,
             is_static_call,
             gas_limit,
             data,
             value,
             code_address,
             code,
-        } = message;
+        } = value;
 
-        let data = env
-            .create_buffer_with_data(data.to_vec())
-            .map(JsBufferValue::into_raw)?;
+        let data = Uint8Array::with_data_copied(data);
 
-        let code = code.as_ref().map_or(Ok(None), |code| {
-            env.create_buffer_with_data(code.original_bytes().to_vec())
-                .map(JsBufferValue::into_raw)
-                .map(Some)
-        })?;
+        let code = code
+            .as_ref()
+            .map(|code| Uint8Array::with_data_copied(code.original_bytes()));
 
-        Ok(TracingMessage {
-            caller: Buffer::from(caller.as_slice()),
-            to: message.to.map(|to| Buffer::from(to.as_slice())),
+        TracingMessage {
+            caller: Uint8Array::with_data_copied(caller),
+            to: to.as_ref().map(Uint8Array::with_data_copied),
             gas_limit: BigInt::from(*gas_limit),
             is_static_call: *is_static_call,
             depth: *depth as u8,
@@ -100,9 +94,9 @@ impl TracingMessage {
                 sign_bit: false,
                 words: value.into_limbs().to_vec(),
             },
-            code_address: code_address.map(|address| Buffer::from(address.to_vec())),
+            code_address: code_address.as_ref().map(Uint8Array::with_data_copied),
             code,
-        })
+        }
     }
 }
 
@@ -124,7 +118,7 @@ pub struct TracingStep {
     pub stack: Vec<BigInt>,
     /// The memory at the step. None if verbose tracing is disabled.
     #[napi(readonly)]
-    pub memory: Option<Buffer>,
+    pub memory: Option<Uint8Array>,
 }
 
 impl TracingStep {
@@ -138,7 +132,7 @@ impl TracingStep {
             },
             |stack| stack.iter().map(u256_to_bigint).collect(),
         );
-        let memory = step.memory.as_ref().cloned().map(Buffer::from);
+        let memory = step.memory.as_ref().map(Uint8Array::with_data_copied);
 
         Self {
             depth: step.depth as u8,
@@ -150,7 +144,7 @@ impl TracingStep {
     }
 }
 
-pub(crate) fn u256_to_bigint(v: &edr_evm::U256) -> BigInt {
+pub(crate) fn u256_to_bigint(v: &edr_eth::U256) -> BigInt {
     BigInt {
         sign_bit: false,
         words: v.into_limbs().to_vec(),
@@ -165,35 +159,34 @@ pub struct TracingMessageResult {
 }
 
 #[napi]
+#[derive(Clone)]
 pub struct RawTrace {
-    pub(crate) inner: Arc<edr_evm::trace::Trace>,
+    inner: Arc<edr_evm::trace::Trace<l1::HaltReason>>,
 }
 
-impl RawTrace {
-    pub fn new(inner: Arc<edr_evm::trace::Trace>) -> Self {
-        Self { inner }
+impl From<Arc<edr_evm::trace::Trace<l1::HaltReason>>> for RawTrace {
+    fn from(value: Arc<edr_evm::trace::Trace<l1::HaltReason>>) -> Self {
+        Self { inner: value }
     }
 }
 
 #[napi]
 impl RawTrace {
-    #[napi]
-    pub fn trace(
-        &self,
-        env: Env,
-    ) -> napi::Result<Vec<Either3<TracingMessage, TracingStep, TracingMessageResult>>> {
+    #[napi(getter)]
+    pub fn trace(&self) -> Vec<Either3<TracingMessage, TracingStep, TracingMessageResult>> {
         self.inner
             .messages
             .iter()
             .map(|message| match message {
                 edr_evm::trace::TraceMessage::Before(message) => {
-                    TracingMessage::new(&env, message).map(Either3::A)
+                    Either3::A(TracingMessage::from(message))
                 }
-                edr_evm::trace::TraceMessage::Step(step) => Ok(Either3::B(TracingStep::new(step))),
-                edr_evm::trace::TraceMessage::After(message) => ExecutionResult::new(&env, message)
-                    .map(|execution_result| Either3::C(TracingMessageResult { execution_result })),
+                edr_evm::trace::TraceMessage::Step(step) => Either3::B(TracingStep::new(step)),
+                edr_evm::trace::TraceMessage::After(message) => Either3::C(TracingMessageResult {
+                    execution_result: ExecutionResult::from(message),
+                }),
             })
-            .collect::<napi::Result<_>>()
+            .collect()
     }
 }
 

package/src/withdrawal.rs

@@ -1,8 +1,8 @@
 use edr_eth::Address;
-use napi::bindgen_prelude::{BigInt, Buffer};
+use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
 
-use crate::cast::TryCast;
+use crate::cast::TryCast as _;
 
 #[napi(object)]
 pub struct Withdrawal {
@@ -11,7 +11,7 @@ pub struct Withdrawal {
     /// The index of the validator that generated the withdrawal
     pub validator_index: BigInt,
     /// The recipient address for withdrawal value
-    pub address: Buffer,
+    pub address: Uint8Array,
     /// The value contained in withdrawal
     pub amount: BigInt,
 }
@@ -21,7 +21,7 @@ impl From<edr_eth::withdrawal::Withdrawal> for Withdrawal {
         Self {
             index: BigInt::from(withdrawal.index),
             validator_index: BigInt::from(withdrawal.validator_index),
-            address: Buffer::from(withdrawal.address.as_slice()),
+            address: Uint8Array::with_data_copied(withdrawal.address),
             amount: BigInt {
                 sign_bit: false,
                 words: withdrawal.amount.as_limbs().to_vec(),