@nomicfoundation/edr 0.12.0-alpha.0 → 0.12.0-next.1

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

@@ -1,4 +1,4 @@
-use napi::{JsFunction, bindgen_prelude::BigInt};
+use napi::{bindgen_prelude::BigInt, JsFunction};
 use napi_derive::napi;
 
 /// Configuration for subscriptions.

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

@@ -64,24 +64,24 @@ impl From<edr_solidity::exit_code::ExitCode<edr_eth::l1::HaltReason>> for ExitCo
             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,
-            ExitCode::Halt(_) => Self::UNKNOWN_HALT_REASON,
+            _ => 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,11 @@
 use napi_derive::napi;
 
-#[napi]
-pub fn link_hex_string_bytecode(code: String, address: String, position: u32) -> String {
+#[napi(catch_unwind)]
+pub fn link_hex_string_bytecode(
+    code: String,
+    address: String,
+    position: u32,
+) -> napi::Result<String> {
     edr_solidity::library_utils::link_hex_string_bytecode(code, &address, position)
+        .map_err(|err| napi::Error::from_reason(err.to_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,7 +31,7 @@ impl ReturnData {
         Self { value, selector }
     }
 
-    #[napi]
+    #[napi(catch_unwind)]
     pub fn is_empty(&self) -> bool {
         self.value.is_empty()
     }
@@ -41,35 +41,35 @@ impl ReturnData {
             .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,7 +1,9 @@
 //! Naive rewrite of `hardhat-network/stack-traces/solidity-stack-traces.ts`
 //! from Hardhat.
 
-use edr_eth::{U256, 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};
@@ -45,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()
 }
@@ -606,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;
@@ -630,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()
@@ -762,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

@@ -9,10 +9,7 @@ use std::sync::Arc;
 
 use edr_eth::{bytecode::opcode::OpCode, l1};
 use edr_evm::trace::BeforeMessage;
-use napi::{
-    Env, JsBuffer, JsBufferValue,
-    bindgen_prelude::{BigInt, Buffer, Either3},
-};
+use napi::bindgen_prelude::{BigInt, Either3, Uint8Array};
 use napi_derive::napi;
 
 use crate::result::ExecutionResult;
@@ -29,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)]
@@ -49,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)]
@@ -58,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,
@@ -101,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,
-        })
+        }
     }
 }
 
@@ -125,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 {
@@ -139,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,
@@ -179,23 +172,21 @@ impl From<Arc<edr_evm::trace::Trace<l1::HaltReason>>> for RawTrace {
 
 #[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,5 +1,5 @@
 use edr_eth::Address;
-use napi::bindgen_prelude::{BigInt, Buffer};
+use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
 
 use crate::cast::TryCast as _;
@@ -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(),